Merge tag 'for_linus' of git://git.kernel.org/pub/scm/linux/kernel/git/bp/bp
[linux-2.6-microblaze.git] / 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 <khali@linux-fr.org>
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         return clamp_val((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 = clamp_val(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 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 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         = 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 <khali@linux-fr.org>");
1108 MODULE_DESCRIPTION("LM78/LM79 driver");
1109 MODULE_LICENSE("GPL");
1110
1111 module_init(sm_lm78_init);
1112 module_exit(sm_lm78_exit);