Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
lm78.c
Go to the documentation of this file.
1 /*
2  * lm78.c - Part of lm_sensors, Linux kernel modules for hardware
3  * monitoring
4  * Copyright (c) 1998, 1999 Frodo Looijaard <[email protected]>
5  * Copyright (c) 2007, 2011 Jean Delvare <[email protected]>
6  *
7  * This program is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License as published by
9  * the Free Software Foundation; either version 2 of the License, or
10  * (at your option) any later version.
11  *
12  * This program is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program; if not, write to the Free Software
19  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
20  */
21 
22 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
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-vid.h>
31 #include <linux/hwmon-sysfs.h>
32 #include <linux/err.h>
33 #include <linux/mutex.h>
34 
35 #ifdef CONFIG_ISA
36 #include <linux/platform_device.h>
37 #include <linux/ioport.h>
38 #include <linux/io.h>
39 #endif
40 
41 /* Addresses to scan */
42 static const unsigned short normal_i2c[] = { 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d,
43  0x2e, 0x2f, I2C_CLIENT_END };
44 enum chips { lm78, lm79 };
45 
46 /* Many LM78 constants specified below */
47 
48 /* Length of ISA address segment */
49 #define LM78_EXTENT 8
50 
51 /* Where are the ISA address/data registers relative to the base address */
52 #define LM78_ADDR_REG_OFFSET 5
53 #define LM78_DATA_REG_OFFSET 6
54 
55 /* The LM78 registers */
56 #define LM78_REG_IN_MAX(nr) (0x2b + (nr) * 2)
57 #define LM78_REG_IN_MIN(nr) (0x2c + (nr) * 2)
58 #define LM78_REG_IN(nr) (0x20 + (nr))
59 
60 #define LM78_REG_FAN_MIN(nr) (0x3b + (nr))
61 #define LM78_REG_FAN(nr) (0x28 + (nr))
62 
63 #define LM78_REG_TEMP 0x27
64 #define LM78_REG_TEMP_OVER 0x39
65 #define LM78_REG_TEMP_HYST 0x3a
66 
67 #define LM78_REG_ALARM1 0x41
68 #define LM78_REG_ALARM2 0x42
69 
70 #define LM78_REG_VID_FANDIV 0x47
71 
72 #define LM78_REG_CONFIG 0x40
73 #define LM78_REG_CHIPID 0x49
74 #define LM78_REG_I2C_ADDR 0x48
75 
76 
77 /*
78  * Conversions. Rounding and limit checking is only done on the TO_REG
79  * variants.
80  */
81 
82 /*
83  * IN: mV (0V to 4.08V)
84  * REG: 16mV/bit
85  */
86 static inline u8 IN_TO_REG(unsigned long val)
87 {
88  unsigned long nval = SENSORS_LIMIT(val, 0, 4080);
89  return (nval + 8) / 16;
90 }
91 #define IN_FROM_REG(val) ((val) * 16)
92 
93 static inline u8 FAN_TO_REG(long rpm, int div)
94 {
95  if (rpm <= 0)
96  return 255;
97  return SENSORS_LIMIT((1350000 + rpm * div / 2) / (rpm * div), 1, 254);
98 }
99 
100 static inline int FAN_FROM_REG(u8 val, int div)
101 {
102  return val == 0 ? -1 : val == 255 ? 0 : 1350000 / (val * div);
103 }
104 
105 /*
106  * TEMP: mC (-128C to +127C)
107  * REG: 1C/bit, two's complement
108  */
109 static inline s8 TEMP_TO_REG(int val)
110 {
111  int nval = SENSORS_LIMIT(val, -128000, 127000) ;
112  return nval < 0 ? (nval - 500) / 1000 : (nval + 500) / 1000;
113 }
114 
115 static inline int TEMP_FROM_REG(s8 val)
116 {
117  return val * 1000;
118 }
119 
120 #define DIV_FROM_REG(val) (1 << (val))
121 
122 struct lm78_data {
123  struct i2c_client *client;
124  struct device *hwmon_dev;
125  struct mutex lock;
126  enum chips type;
127 
128  /* For ISA device only */
129  const char *name;
130  int isa_addr;
131 
132  struct mutex update_lock;
133  char valid; /* !=0 if following fields are valid */
134  unsigned long last_updated; /* In jiffies */
135 
136  u8 in[7]; /* Register value */
137  u8 in_max[7]; /* Register value */
138  u8 in_min[7]; /* Register value */
139  u8 fan[3]; /* Register value */
140  u8 fan_min[3]; /* Register value */
141  s8 temp; /* Register value */
142  s8 temp_over; /* Register value */
143  s8 temp_hyst; /* Register value */
144  u8 fan_div[3]; /* Register encoding, shifted right */
145  u8 vid; /* Register encoding, combined */
146  u16 alarms; /* Register encoding, combined */
147 };
148 
149 
150 static int lm78_read_value(struct lm78_data *data, u8 reg);
151 static int lm78_write_value(struct lm78_data *data, u8 reg, u8 value);
152 static struct lm78_data *lm78_update_device(struct device *dev);
153 static void lm78_init_device(struct lm78_data *data);
154 
155 
156 /* 7 Voltages */
157 static ssize_t show_in(struct device *dev, struct device_attribute *da,
158  char *buf)
159 {
160  struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
161  struct lm78_data *data = lm78_update_device(dev);
162  return sprintf(buf, "%d\n", IN_FROM_REG(data->in[attr->index]));
163 }
164 
165 static ssize_t show_in_min(struct device *dev, struct device_attribute *da,
166  char *buf)
167 {
168  struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
169  struct lm78_data *data = lm78_update_device(dev);
170  return sprintf(buf, "%d\n", IN_FROM_REG(data->in_min[attr->index]));
171 }
172 
173 static ssize_t show_in_max(struct device *dev, struct device_attribute *da,
174  char *buf)
175 {
176  struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
177  struct lm78_data *data = lm78_update_device(dev);
178  return sprintf(buf, "%d\n", IN_FROM_REG(data->in_max[attr->index]));
179 }
180 
181 static ssize_t set_in_min(struct device *dev, struct device_attribute *da,
182  const char *buf, size_t count)
183 {
184  struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
185  struct lm78_data *data = dev_get_drvdata(dev);
186  int nr = attr->index;
187  unsigned long val;
188  int err;
189 
190  err = kstrtoul(buf, 10, &val);
191  if (err)
192  return err;
193 
194  mutex_lock(&data->update_lock);
195  data->in_min[nr] = IN_TO_REG(val);
196  lm78_write_value(data, LM78_REG_IN_MIN(nr), data->in_min[nr]);
197  mutex_unlock(&data->update_lock);
198  return count;
199 }
200 
201 static ssize_t set_in_max(struct device *dev, struct device_attribute *da,
202  const char *buf, size_t count)
203 {
204  struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
205  struct lm78_data *data = dev_get_drvdata(dev);
206  int nr = attr->index;
207  unsigned long val;
208  int err;
209 
210  err = kstrtoul(buf, 10, &val);
211  if (err)
212  return err;
213 
214  mutex_lock(&data->update_lock);
215  data->in_max[nr] = IN_TO_REG(val);
216  lm78_write_value(data, LM78_REG_IN_MAX(nr), data->in_max[nr]);
217  mutex_unlock(&data->update_lock);
218  return count;
219 }
220 
221 #define show_in_offset(offset) \
222 static SENSOR_DEVICE_ATTR(in##offset##_input, S_IRUGO, \
223  show_in, NULL, offset); \
224 static SENSOR_DEVICE_ATTR(in##offset##_min, S_IRUGO | S_IWUSR, \
225  show_in_min, set_in_min, offset); \
226 static SENSOR_DEVICE_ATTR(in##offset##_max, S_IRUGO | S_IWUSR, \
227  show_in_max, set_in_max, offset);
228 
229 show_in_offset(0);
230 show_in_offset(1);
231 show_in_offset(2);
232 show_in_offset(3);
233 show_in_offset(4);
234 show_in_offset(5);
235 show_in_offset(6);
236 
237 /* Temperature */
238 static ssize_t show_temp(struct device *dev, struct device_attribute *da,
239  char *buf)
240 {
241  struct lm78_data *data = lm78_update_device(dev);
242  return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp));
243 }
244 
245 static ssize_t show_temp_over(struct device *dev, struct device_attribute *da,
246  char *buf)
247 {
248  struct lm78_data *data = lm78_update_device(dev);
249  return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_over));
250 }
251 
252 static ssize_t set_temp_over(struct device *dev, struct device_attribute *da,
253  const char *buf, size_t count)
254 {
255  struct lm78_data *data = dev_get_drvdata(dev);
256  long val;
257  int err;
258 
259  err = kstrtol(buf, 10, &val);
260  if (err)
261  return err;
262 
263  mutex_lock(&data->update_lock);
264  data->temp_over = TEMP_TO_REG(val);
265  lm78_write_value(data, LM78_REG_TEMP_OVER, data->temp_over);
266  mutex_unlock(&data->update_lock);
267  return count;
268 }
269 
270 static ssize_t show_temp_hyst(struct device *dev, struct device_attribute *da,
271  char *buf)
272 {
273  struct lm78_data *data = lm78_update_device(dev);
274  return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_hyst));
275 }
276 
277 static ssize_t set_temp_hyst(struct device *dev, struct device_attribute *da,
278  const char *buf, size_t count)
279 {
280  struct lm78_data *data = dev_get_drvdata(dev);
281  long val;
282  int err;
283 
284  err = kstrtol(buf, 10, &val);
285  if (err)
286  return err;
287 
288  mutex_lock(&data->update_lock);
289  data->temp_hyst = TEMP_TO_REG(val);
290  lm78_write_value(data, LM78_REG_TEMP_HYST, data->temp_hyst);
291  mutex_unlock(&data->update_lock);
292  return count;
293 }
294 
295 static DEVICE_ATTR(temp1_input, S_IRUGO, show_temp, NULL);
296 static DEVICE_ATTR(temp1_max, S_IRUGO | S_IWUSR,
297  show_temp_over, set_temp_over);
298 static DEVICE_ATTR(temp1_max_hyst, S_IRUGO | S_IWUSR,
299  show_temp_hyst, set_temp_hyst);
300 
301 /* 3 Fans */
302 static ssize_t show_fan(struct device *dev, struct device_attribute *da,
303  char *buf)
304 {
305  struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
306  struct lm78_data *data = lm78_update_device(dev);
307  int nr = attr->index;
308  return sprintf(buf, "%d\n", FAN_FROM_REG(data->fan[nr],
309  DIV_FROM_REG(data->fan_div[nr])));
310 }
311 
312 static ssize_t show_fan_min(struct device *dev, struct device_attribute *da,
313  char *buf)
314 {
315  struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
316  struct lm78_data *data = lm78_update_device(dev);
317  int nr = attr->index;
318  return sprintf(buf, "%d\n", FAN_FROM_REG(data->fan_min[nr],
319  DIV_FROM_REG(data->fan_div[nr])));
320 }
321 
322 static ssize_t set_fan_min(struct device *dev, struct device_attribute *da,
323  const char *buf, size_t count)
324 {
325  struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
326  struct lm78_data *data = dev_get_drvdata(dev);
327  int nr = attr->index;
328  unsigned long val;
329  int err;
330 
331  err = kstrtoul(buf, 10, &val);
332  if (err)
333  return err;
334 
335  mutex_lock(&data->update_lock);
336  data->fan_min[nr] = FAN_TO_REG(val, DIV_FROM_REG(data->fan_div[nr]));
337  lm78_write_value(data, LM78_REG_FAN_MIN(nr), data->fan_min[nr]);
338  mutex_unlock(&data->update_lock);
339  return count;
340 }
341 
342 static ssize_t show_fan_div(struct device *dev, struct device_attribute *da,
343  char *buf)
344 {
345  struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
346  struct lm78_data *data = lm78_update_device(dev);
347  return sprintf(buf, "%d\n", DIV_FROM_REG(data->fan_div[attr->index]));
348 }
349 
350 /*
351  * Note: we save and restore the fan minimum here, because its value is
352  * determined in part by the fan divisor. This follows the principle of
353  * least surprise; the user doesn't expect the fan minimum to change just
354  * because the divisor changed.
355  */
356 static ssize_t set_fan_div(struct device *dev, struct device_attribute *da,
357  const char *buf, size_t count)
358 {
359  struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
360  struct lm78_data *data = dev_get_drvdata(dev);
361  int nr = attr->index;
362  unsigned long min;
363  u8 reg;
364  unsigned long val;
365  int err;
366 
367  err = kstrtoul(buf, 10, &val);
368  if (err)
369  return err;
370 
371  mutex_lock(&data->update_lock);
372  min = FAN_FROM_REG(data->fan_min[nr],
373  DIV_FROM_REG(data->fan_div[nr]));
374 
375  switch (val) {
376  case 1:
377  data->fan_div[nr] = 0;
378  break;
379  case 2:
380  data->fan_div[nr] = 1;
381  break;
382  case 4:
383  data->fan_div[nr] = 2;
384  break;
385  case 8:
386  data->fan_div[nr] = 3;
387  break;
388  default:
389  dev_err(dev, "fan_div value %ld not "
390  "supported. Choose one of 1, 2, 4 or 8!\n", val);
391  mutex_unlock(&data->update_lock);
392  return -EINVAL;
393  }
394 
395  reg = lm78_read_value(data, LM78_REG_VID_FANDIV);
396  switch (nr) {
397  case 0:
398  reg = (reg & 0xcf) | (data->fan_div[nr] << 4);
399  break;
400  case 1:
401  reg = (reg & 0x3f) | (data->fan_div[nr] << 6);
402  break;
403  }
404  lm78_write_value(data, LM78_REG_VID_FANDIV, reg);
405 
406  data->fan_min[nr] =
407  FAN_TO_REG(min, DIV_FROM_REG(data->fan_div[nr]));
408  lm78_write_value(data, LM78_REG_FAN_MIN(nr), data->fan_min[nr]);
409  mutex_unlock(&data->update_lock);
410 
411  return count;
412 }
413 
414 #define show_fan_offset(offset) \
415 static SENSOR_DEVICE_ATTR(fan##offset##_input, S_IRUGO, \
416  show_fan, NULL, offset - 1); \
417 static SENSOR_DEVICE_ATTR(fan##offset##_min, S_IRUGO | S_IWUSR, \
418  show_fan_min, set_fan_min, offset - 1);
419 
420 show_fan_offset(1);
421 show_fan_offset(2);
422 show_fan_offset(3);
423 
424 /* Fan 3 divisor is locked in H/W */
425 static SENSOR_DEVICE_ATTR(fan1_div, S_IRUGO | S_IWUSR,
426  show_fan_div, set_fan_div, 0);
427 static SENSOR_DEVICE_ATTR(fan2_div, S_IRUGO | S_IWUSR,
428  show_fan_div, set_fan_div, 1);
429 static SENSOR_DEVICE_ATTR(fan3_div, S_IRUGO, show_fan_div, NULL, 2);
430 
431 /* VID */
432 static ssize_t show_vid(struct device *dev, struct device_attribute *da,
433  char *buf)
434 {
435  struct lm78_data *data = lm78_update_device(dev);
436  return sprintf(buf, "%d\n", vid_from_reg(data->vid, 82));
437 }
438 static DEVICE_ATTR(cpu0_vid, S_IRUGO, show_vid, NULL);
439 
440 /* Alarms */
441 static ssize_t show_alarms(struct device *dev, struct device_attribute *da,
442  char *buf)
443 {
444  struct lm78_data *data = lm78_update_device(dev);
445  return sprintf(buf, "%u\n", data->alarms);
446 }
447 static DEVICE_ATTR(alarms, S_IRUGO, show_alarms, NULL);
448 
449 static ssize_t show_alarm(struct device *dev, struct device_attribute *da,
450  char *buf)
451 {
452  struct lm78_data *data = lm78_update_device(dev);
453  int nr = to_sensor_dev_attr(da)->index;
454  return sprintf(buf, "%u\n", (data->alarms >> nr) & 1);
455 }
456 static SENSOR_DEVICE_ATTR(in0_alarm, S_IRUGO, show_alarm, NULL, 0);
457 static SENSOR_DEVICE_ATTR(in1_alarm, S_IRUGO, show_alarm, NULL, 1);
458 static SENSOR_DEVICE_ATTR(in2_alarm, S_IRUGO, show_alarm, NULL, 2);
459 static SENSOR_DEVICE_ATTR(in3_alarm, S_IRUGO, show_alarm, NULL, 3);
460 static SENSOR_DEVICE_ATTR(in4_alarm, S_IRUGO, show_alarm, NULL, 8);
461 static SENSOR_DEVICE_ATTR(in5_alarm, S_IRUGO, show_alarm, NULL, 9);
462 static SENSOR_DEVICE_ATTR(in6_alarm, S_IRUGO, show_alarm, NULL, 10);
463 static SENSOR_DEVICE_ATTR(fan1_alarm, S_IRUGO, show_alarm, NULL, 6);
464 static SENSOR_DEVICE_ATTR(fan2_alarm, S_IRUGO, show_alarm, NULL, 7);
465 static SENSOR_DEVICE_ATTR(fan3_alarm, S_IRUGO, show_alarm, NULL, 11);
466 static SENSOR_DEVICE_ATTR(temp1_alarm, S_IRUGO, show_alarm, NULL, 4);
467 
468 static struct attribute *lm78_attributes[] = {
469  &sensor_dev_attr_in0_input.dev_attr.attr,
470  &sensor_dev_attr_in0_min.dev_attr.attr,
471  &sensor_dev_attr_in0_max.dev_attr.attr,
472  &sensor_dev_attr_in0_alarm.dev_attr.attr,
473  &sensor_dev_attr_in1_input.dev_attr.attr,
474  &sensor_dev_attr_in1_min.dev_attr.attr,
475  &sensor_dev_attr_in1_max.dev_attr.attr,
476  &sensor_dev_attr_in1_alarm.dev_attr.attr,
477  &sensor_dev_attr_in2_input.dev_attr.attr,
478  &sensor_dev_attr_in2_min.dev_attr.attr,
479  &sensor_dev_attr_in2_max.dev_attr.attr,
480  &sensor_dev_attr_in2_alarm.dev_attr.attr,
481  &sensor_dev_attr_in3_input.dev_attr.attr,
482  &sensor_dev_attr_in3_min.dev_attr.attr,
483  &sensor_dev_attr_in3_max.dev_attr.attr,
484  &sensor_dev_attr_in3_alarm.dev_attr.attr,
485  &sensor_dev_attr_in4_input.dev_attr.attr,
486  &sensor_dev_attr_in4_min.dev_attr.attr,
487  &sensor_dev_attr_in4_max.dev_attr.attr,
488  &sensor_dev_attr_in4_alarm.dev_attr.attr,
489  &sensor_dev_attr_in5_input.dev_attr.attr,
490  &sensor_dev_attr_in5_min.dev_attr.attr,
491  &sensor_dev_attr_in5_max.dev_attr.attr,
492  &sensor_dev_attr_in5_alarm.dev_attr.attr,
493  &sensor_dev_attr_in6_input.dev_attr.attr,
494  &sensor_dev_attr_in6_min.dev_attr.attr,
495  &sensor_dev_attr_in6_max.dev_attr.attr,
496  &sensor_dev_attr_in6_alarm.dev_attr.attr,
497  &dev_attr_temp1_input.attr,
498  &dev_attr_temp1_max.attr,
499  &dev_attr_temp1_max_hyst.attr,
500  &sensor_dev_attr_temp1_alarm.dev_attr.attr,
501  &sensor_dev_attr_fan1_input.dev_attr.attr,
502  &sensor_dev_attr_fan1_min.dev_attr.attr,
503  &sensor_dev_attr_fan1_div.dev_attr.attr,
504  &sensor_dev_attr_fan1_alarm.dev_attr.attr,
505  &sensor_dev_attr_fan2_input.dev_attr.attr,
506  &sensor_dev_attr_fan2_min.dev_attr.attr,
507  &sensor_dev_attr_fan2_div.dev_attr.attr,
508  &sensor_dev_attr_fan2_alarm.dev_attr.attr,
509  &sensor_dev_attr_fan3_input.dev_attr.attr,
510  &sensor_dev_attr_fan3_min.dev_attr.attr,
511  &sensor_dev_attr_fan3_div.dev_attr.attr,
512  &sensor_dev_attr_fan3_alarm.dev_attr.attr,
513  &dev_attr_alarms.attr,
514  &dev_attr_cpu0_vid.attr,
515 
516  NULL
517 };
518 
519 static const struct attribute_group lm78_group = {
520  .attrs = lm78_attributes,
521 };
522 
523 /*
524  * ISA related code
525  */
526 #ifdef CONFIG_ISA
527 
528 /* ISA device, if found */
529 static struct platform_device *pdev;
530 
531 static unsigned short isa_address = 0x290;
532 
533 /*
534  * I2C devices get this name attribute automatically, but for ISA devices
535  * we must create it by ourselves.
536  */
537 static ssize_t show_name(struct device *dev, struct device_attribute
538  *devattr, char *buf)
539 {
540  struct lm78_data *data = dev_get_drvdata(dev);
541 
542  return sprintf(buf, "%s\n", data->name);
543 }
544 static DEVICE_ATTR(name, S_IRUGO, show_name, NULL);
545 
546 static struct lm78_data *lm78_data_if_isa(void)
547 {
548  return pdev ? platform_get_drvdata(pdev) : NULL;
549 }
550 
551 /* Returns 1 if the I2C chip appears to be an alias of the ISA chip */
552 static int lm78_alias_detect(struct i2c_client *client, u8 chipid)
553 {
554  struct lm78_data *isa;
555  int i;
556 
557  if (!pdev) /* No ISA chip */
558  return 0;
559  isa = platform_get_drvdata(pdev);
560 
561  if (lm78_read_value(isa, LM78_REG_I2C_ADDR) != client->addr)
562  return 0; /* Address doesn't match */
563  if ((lm78_read_value(isa, LM78_REG_CHIPID) & 0xfe) != (chipid & 0xfe))
564  return 0; /* Chip type doesn't match */
565 
566  /*
567  * We compare all the limit registers, the config register and the
568  * interrupt mask registers
569  */
570  for (i = 0x2b; i <= 0x3d; i++) {
571  if (lm78_read_value(isa, i) !=
572  i2c_smbus_read_byte_data(client, i))
573  return 0;
574  }
575  if (lm78_read_value(isa, LM78_REG_CONFIG) !=
576  i2c_smbus_read_byte_data(client, LM78_REG_CONFIG))
577  return 0;
578  for (i = 0x43; i <= 0x46; i++) {
579  if (lm78_read_value(isa, i) !=
580  i2c_smbus_read_byte_data(client, i))
581  return 0;
582  }
583 
584  return 1;
585 }
586 #else /* !CONFIG_ISA */
587 
588 static int lm78_alias_detect(struct i2c_client *client, u8 chipid)
589 {
590  return 0;
591 }
592 
593 static struct lm78_data *lm78_data_if_isa(void)
594 {
595  return NULL;
596 }
597 #endif /* CONFIG_ISA */
598 
599 static int lm78_i2c_detect(struct i2c_client *client,
600  struct i2c_board_info *info)
601 {
602  int i;
603  struct lm78_data *isa = lm78_data_if_isa();
604  const char *client_name;
605  struct i2c_adapter *adapter = client->adapter;
606  int address = client->addr;
607 
608  if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
609  return -ENODEV;
610 
611  /*
612  * We block updates of the ISA device to minimize the risk of
613  * concurrent access to the same LM78 chip through different
614  * interfaces.
615  */
616  if (isa)
617  mutex_lock(&isa->update_lock);
618 
619  if ((i2c_smbus_read_byte_data(client, LM78_REG_CONFIG) & 0x80)
620  || i2c_smbus_read_byte_data(client, LM78_REG_I2C_ADDR) != address)
621  goto err_nodev;
622 
623  /* Explicitly prevent the misdetection of Winbond chips */
624  i = i2c_smbus_read_byte_data(client, 0x4f);
625  if (i == 0xa3 || i == 0x5c)
626  goto err_nodev;
627 
628  /* Determine the chip type. */
629  i = i2c_smbus_read_byte_data(client, LM78_REG_CHIPID);
630  if (i == 0x00 || i == 0x20 /* LM78 */
631  || i == 0x40) /* LM78-J */
632  client_name = "lm78";
633  else if ((i & 0xfe) == 0xc0)
634  client_name = "lm79";
635  else
636  goto err_nodev;
637 
638  if (lm78_alias_detect(client, i)) {
639  dev_dbg(&adapter->dev, "Device at 0x%02x appears to "
640  "be the same as ISA device\n", address);
641  goto err_nodev;
642  }
643 
644  if (isa)
645  mutex_unlock(&isa->update_lock);
646 
647  strlcpy(info->type, client_name, I2C_NAME_SIZE);
648 
649  return 0;
650 
651  err_nodev:
652  if (isa)
653  mutex_unlock(&isa->update_lock);
654  return -ENODEV;
655 }
656 
657 static int lm78_i2c_probe(struct i2c_client *client,
658  const struct i2c_device_id *id)
659 {
660  struct lm78_data *data;
661  int err;
662 
663  data = devm_kzalloc(&client->dev, sizeof(struct lm78_data), GFP_KERNEL);
664  if (!data)
665  return -ENOMEM;
666 
667  i2c_set_clientdata(client, data);
668  data->client = client;
669  data->type = id->driver_data;
670 
671  /* Initialize the LM78 chip */
672  lm78_init_device(data);
673 
674  /* Register sysfs hooks */
675  err = sysfs_create_group(&client->dev.kobj, &lm78_group);
676  if (err)
677  return err;
678 
679  data->hwmon_dev = hwmon_device_register(&client->dev);
680  if (IS_ERR(data->hwmon_dev)) {
681  err = PTR_ERR(data->hwmon_dev);
682  goto error;
683  }
684 
685  return 0;
686 
687 error:
688  sysfs_remove_group(&client->dev.kobj, &lm78_group);
689  return err;
690 }
691 
692 static int lm78_i2c_remove(struct i2c_client *client)
693 {
694  struct lm78_data *data = i2c_get_clientdata(client);
695 
696  hwmon_device_unregister(data->hwmon_dev);
697  sysfs_remove_group(&client->dev.kobj, &lm78_group);
698 
699  return 0;
700 }
701 
702 static const struct i2c_device_id lm78_i2c_id[] = {
703  { "lm78", lm78 },
704  { "lm79", lm79 },
705  { }
706 };
707 MODULE_DEVICE_TABLE(i2c, lm78_i2c_id);
708 
709 static struct i2c_driver lm78_driver = {
710  .class = I2C_CLASS_HWMON,
711  .driver = {
712  .name = "lm78",
713  },
714  .probe = lm78_i2c_probe,
715  .remove = lm78_i2c_remove,
716  .id_table = lm78_i2c_id,
717  .detect = lm78_i2c_detect,
718  .address_list = normal_i2c,
719 };
720 
721 /*
722  * The SMBus locks itself, but ISA access must be locked explicitly!
723  * We don't want to lock the whole ISA bus, so we lock each client
724  * separately.
725  * We ignore the LM78 BUSY flag at this moment - it could lead to deadlocks,
726  * would slow down the LM78 access and should not be necessary.
727  */
728 static int lm78_read_value(struct lm78_data *data, u8 reg)
729 {
730  struct i2c_client *client = data->client;
731 
732 #ifdef CONFIG_ISA
733  if (!client) { /* ISA device */
734  int res;
735  mutex_lock(&data->lock);
736  outb_p(reg, data->isa_addr + LM78_ADDR_REG_OFFSET);
737  res = inb_p(data->isa_addr + LM78_DATA_REG_OFFSET);
738  mutex_unlock(&data->lock);
739  return res;
740  } else
741 #endif
742  return i2c_smbus_read_byte_data(client, reg);
743 }
744 
745 static int lm78_write_value(struct lm78_data *data, u8 reg, u8 value)
746 {
747  struct i2c_client *client = data->client;
748 
749 #ifdef CONFIG_ISA
750  if (!client) { /* ISA device */
751  mutex_lock(&data->lock);
752  outb_p(reg, data->isa_addr + LM78_ADDR_REG_OFFSET);
753  outb_p(value, data->isa_addr + LM78_DATA_REG_OFFSET);
754  mutex_unlock(&data->lock);
755  return 0;
756  } else
757 #endif
758  return i2c_smbus_write_byte_data(client, reg, value);
759 }
760 
761 static void lm78_init_device(struct lm78_data *data)
762 {
763  u8 config;
764  int i;
765 
766  /* Start monitoring */
767  config = lm78_read_value(data, LM78_REG_CONFIG);
768  if ((config & 0x09) != 0x01)
769  lm78_write_value(data, LM78_REG_CONFIG,
770  (config & 0xf7) | 0x01);
771 
772  /* A few vars need to be filled upon startup */
773  for (i = 0; i < 3; i++) {
774  data->fan_min[i] = lm78_read_value(data,
775  LM78_REG_FAN_MIN(i));
776  }
777 
778  mutex_init(&data->update_lock);
779 }
780 
781 static struct lm78_data *lm78_update_device(struct device *dev)
782 {
783  struct lm78_data *data = dev_get_drvdata(dev);
784  int i;
785 
786  mutex_lock(&data->update_lock);
787 
788  if (time_after(jiffies, data->last_updated + HZ + HZ / 2)
789  || !data->valid) {
790 
791  dev_dbg(dev, "Starting lm78 update\n");
792 
793  for (i = 0; i <= 6; i++) {
794  data->in[i] =
795  lm78_read_value(data, LM78_REG_IN(i));
796  data->in_min[i] =
797  lm78_read_value(data, LM78_REG_IN_MIN(i));
798  data->in_max[i] =
799  lm78_read_value(data, LM78_REG_IN_MAX(i));
800  }
801  for (i = 0; i < 3; i++) {
802  data->fan[i] =
803  lm78_read_value(data, LM78_REG_FAN(i));
804  data->fan_min[i] =
805  lm78_read_value(data, LM78_REG_FAN_MIN(i));
806  }
807  data->temp = lm78_read_value(data, LM78_REG_TEMP);
808  data->temp_over =
809  lm78_read_value(data, LM78_REG_TEMP_OVER);
810  data->temp_hyst =
811  lm78_read_value(data, LM78_REG_TEMP_HYST);
812  i = lm78_read_value(data, LM78_REG_VID_FANDIV);
813  data->vid = i & 0x0f;
814  if (data->type == lm79)
815  data->vid |=
816  (lm78_read_value(data, LM78_REG_CHIPID) &
817  0x01) << 4;
818  else
819  data->vid |= 0x10;
820  data->fan_div[0] = (i >> 4) & 0x03;
821  data->fan_div[1] = i >> 6;
822  data->alarms = lm78_read_value(data, LM78_REG_ALARM1) +
823  (lm78_read_value(data, LM78_REG_ALARM2) << 8);
824  data->last_updated = jiffies;
825  data->valid = 1;
826 
827  data->fan_div[2] = 1;
828  }
829 
830  mutex_unlock(&data->update_lock);
831 
832  return data;
833 }
834 
835 #ifdef CONFIG_ISA
836 static int __devinit lm78_isa_probe(struct platform_device *pdev)
837 {
838  int err;
839  struct lm78_data *data;
840  struct resource *res;
841 
842  /* Reserve the ISA region */
843  res = platform_get_resource(pdev, IORESOURCE_IO, 0);
844  if (!devm_request_region(&pdev->dev, res->start + LM78_ADDR_REG_OFFSET,
845  2, "lm78"))
846  return -EBUSY;
847 
848  data = devm_kzalloc(&pdev->dev, sizeof(struct lm78_data), GFP_KERNEL);
849  if (!data)
850  return -ENOMEM;
851 
852  mutex_init(&data->lock);
853  data->isa_addr = res->start;
854  platform_set_drvdata(pdev, data);
855 
856  if (lm78_read_value(data, LM78_REG_CHIPID) & 0x80) {
857  data->type = lm79;
858  data->name = "lm79";
859  } else {
860  data->type = lm78;
861  data->name = "lm78";
862  }
863 
864  /* Initialize the LM78 chip */
865  lm78_init_device(data);
866 
867  /* Register sysfs hooks */
868  err = sysfs_create_group(&pdev->dev.kobj, &lm78_group);
869  if (err)
870  goto exit_remove_files;
871  err = device_create_file(&pdev->dev, &dev_attr_name);
872  if (err)
873  goto exit_remove_files;
874 
875  data->hwmon_dev = hwmon_device_register(&pdev->dev);
876  if (IS_ERR(data->hwmon_dev)) {
877  err = PTR_ERR(data->hwmon_dev);
878  goto exit_remove_files;
879  }
880 
881  return 0;
882 
883  exit_remove_files:
884  sysfs_remove_group(&pdev->dev.kobj, &lm78_group);
885  device_remove_file(&pdev->dev, &dev_attr_name);
886  return err;
887 }
888 
889 static int __devexit lm78_isa_remove(struct platform_device *pdev)
890 {
891  struct lm78_data *data = platform_get_drvdata(pdev);
892 
893  hwmon_device_unregister(data->hwmon_dev);
894  sysfs_remove_group(&pdev->dev.kobj, &lm78_group);
895  device_remove_file(&pdev->dev, &dev_attr_name);
896 
897  return 0;
898 }
899 
900 static struct platform_driver lm78_isa_driver = {
901  .driver = {
902  .owner = THIS_MODULE,
903  .name = "lm78",
904  },
905  .probe = lm78_isa_probe,
906  .remove = __devexit_p(lm78_isa_remove),
907 };
908 
909 /* return 1 if a supported chip is found, 0 otherwise */
910 static int __init lm78_isa_found(unsigned short address)
911 {
912  int val, save, found = 0;
913  int port;
914 
915  /*
916  * Some boards declare base+0 to base+7 as a PNP device, some base+4
917  * to base+7 and some base+5 to base+6. So we better request each port
918  * individually for the probing phase.
919  */
920  for (port = address; port < address + LM78_EXTENT; port++) {
921  if (!request_region(port, 1, "lm78")) {
922  pr_debug("Failed to request port 0x%x\n", port);
923  goto release;
924  }
925  }
926 
927 #define REALLY_SLOW_IO
928  /*
929  * We need the timeouts for at least some LM78-like
930  * chips. But only if we read 'undefined' registers.
931  */
932  val = inb_p(address + 1);
933  if (inb_p(address + 2) != val
934  || inb_p(address + 3) != val
935  || inb_p(address + 7) != val)
936  goto release;
937 #undef REALLY_SLOW_IO
938 
939  /*
940  * We should be able to change the 7 LSB of the address port. The
941  * MSB (busy flag) should be clear initially, set after the write.
942  */
943  save = inb_p(address + LM78_ADDR_REG_OFFSET);
944  if (save & 0x80)
945  goto release;
946  val = ~save & 0x7f;
947  outb_p(val, address + LM78_ADDR_REG_OFFSET);
948  if (inb_p(address + LM78_ADDR_REG_OFFSET) != (val | 0x80)) {
949  outb_p(save, address + LM78_ADDR_REG_OFFSET);
950  goto release;
951  }
952 
953  /* We found a device, now see if it could be an LM78 */
954  outb_p(LM78_REG_CONFIG, address + LM78_ADDR_REG_OFFSET);
955  val = inb_p(address + LM78_DATA_REG_OFFSET);
956  if (val & 0x80)
957  goto release;
958  outb_p(LM78_REG_I2C_ADDR, address + LM78_ADDR_REG_OFFSET);
959  val = inb_p(address + LM78_DATA_REG_OFFSET);
960  if (val < 0x03 || val > 0x77) /* Not a valid I2C address */
961  goto release;
962 
963  /* The busy flag should be clear again */
964  if (inb_p(address + LM78_ADDR_REG_OFFSET) & 0x80)
965  goto release;
966 
967  /* Explicitly prevent the misdetection of Winbond chips */
968  outb_p(0x4f, address + LM78_ADDR_REG_OFFSET);
969  val = inb_p(address + LM78_DATA_REG_OFFSET);
970  if (val == 0xa3 || val == 0x5c)
971  goto release;
972 
973  /* Explicitly prevent the misdetection of ITE chips */
974  outb_p(0x58, address + LM78_ADDR_REG_OFFSET);
975  val = inb_p(address + LM78_DATA_REG_OFFSET);
976  if (val == 0x90)
977  goto release;
978 
979  /* Determine the chip type */
980  outb_p(LM78_REG_CHIPID, address + LM78_ADDR_REG_OFFSET);
981  val = inb_p(address + LM78_DATA_REG_OFFSET);
982  if (val == 0x00 || val == 0x20 /* LM78 */
983  || val == 0x40 /* LM78-J */
984  || (val & 0xfe) == 0xc0) /* LM79 */
985  found = 1;
986 
987  if (found)
988  pr_info("Found an %s chip at %#x\n",
989  val & 0x80 ? "LM79" : "LM78", (int)address);
990 
991  release:
992  for (port--; port >= address; port--)
993  release_region(port, 1);
994  return found;
995 }
996 
997 static int __init lm78_isa_device_add(unsigned short address)
998 {
999  struct resource res = {
1000  .start = address,
1001  .end = address + LM78_EXTENT - 1,
1002  .name = "lm78",
1003  .flags = IORESOURCE_IO,
1004  };
1005  int err;
1006 
1007  pdev = platform_device_alloc("lm78", address);
1008  if (!pdev) {
1009  err = -ENOMEM;
1010  pr_err("Device allocation failed\n");
1011  goto exit;
1012  }
1013 
1014  err = platform_device_add_resources(pdev, &res, 1);
1015  if (err) {
1016  pr_err("Device resource addition failed (%d)\n", err);
1017  goto exit_device_put;
1018  }
1019 
1020  err = platform_device_add(pdev);
1021  if (err) {
1022  pr_err("Device addition failed (%d)\n", err);
1023  goto exit_device_put;
1024  }
1025 
1026  return 0;
1027 
1028  exit_device_put:
1029  platform_device_put(pdev);
1030  exit:
1031  pdev = NULL;
1032  return err;
1033 }
1034 
1035 static int __init lm78_isa_register(void)
1036 {
1037  int res;
1038 
1039  if (lm78_isa_found(isa_address)) {
1040  res = platform_driver_register(&lm78_isa_driver);
1041  if (res)
1042  goto exit;
1043 
1044  /* Sets global pdev as a side effect */
1045  res = lm78_isa_device_add(isa_address);
1046  if (res)
1047  goto exit_unreg_isa_driver;
1048  }
1049 
1050  return 0;
1051 
1052  exit_unreg_isa_driver:
1053  platform_driver_unregister(&lm78_isa_driver);
1054  exit:
1055  return res;
1056 }
1057 
1058 static void lm78_isa_unregister(void)
1059 {
1060  if (pdev) {
1061  platform_device_unregister(pdev);
1062  platform_driver_unregister(&lm78_isa_driver);
1063  }
1064 }
1065 #else /* !CONFIG_ISA */
1066 
1067 static int __init lm78_isa_register(void)
1068 {
1069  return 0;
1070 }
1071 
1072 static void lm78_isa_unregister(void)
1073 {
1074 }
1075 #endif /* CONFIG_ISA */
1076 
1077 static int __init sm_lm78_init(void)
1078 {
1079  int res;
1080 
1081  /*
1082  * We register the ISA device first, so that we can skip the
1083  * registration of an I2C interface to the same device.
1084  */
1085  res = lm78_isa_register();
1086  if (res)
1087  goto exit;
1088 
1089  res = i2c_add_driver(&lm78_driver);
1090  if (res)
1091  goto exit_unreg_isa_device;
1092 
1093  return 0;
1094 
1095  exit_unreg_isa_device:
1096  lm78_isa_unregister();
1097  exit:
1098  return res;
1099 }
1100 
1101 static void __exit sm_lm78_exit(void)
1102 {
1103  lm78_isa_unregister();
1104  i2c_del_driver(&lm78_driver);
1105 }
1106 
1107 MODULE_AUTHOR("Frodo Looijaard, Jean Delvare <[email protected]>");
1108 MODULE_DESCRIPTION("LM78/LM79 driver");
1109 MODULE_LICENSE("GPL");
1110 
1111 module_init(sm_lm78_init);
1112 module_exit(sm_lm78_exit);
Generated on Thu Jan 10 2013 13:34:59 for Linux Kernel by   doxygen 1.8.2