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