Version:  2.0.40 2.2.26 2.4.37 3.0 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

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

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