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