Version:  2.0.40 2.2.26 2.4.37 3.1 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15 3.16 3.17

Linux/drivers/hwmon/lm78.c

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

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us