Staging: rtl8187se: fix printk format warnings
[linux-2.6] / 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 <asm/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         = 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 (kind < 0) {
580                 if ((i2c_smbus_read_byte_data(client, LM78_REG_CONFIG) & 0x80)
581                  || i2c_smbus_read_byte_data(client, LM78_REG_I2C_ADDR)
582                     != address)
583                         goto err_nodev;
584
585                 /* Explicitly prevent the misdetection of Winbond chips */
586                 i = i2c_smbus_read_byte_data(client, 0x4f);
587                 if (i == 0xa3 || i == 0x5c)
588                         goto err_nodev;
589         }
590
591         /* Determine the chip type. */
592         if (kind <= 0) {
593                 i = i2c_smbus_read_byte_data(client, LM78_REG_CHIPID);
594                 if (i == 0x00 || i == 0x20      /* LM78 */
595                  || i == 0x40)                  /* LM78-J */
596                         kind = lm78;
597                 else if ((i & 0xfe) == 0xc0)
598                         kind = lm79;
599                 else {
600                         if (kind == 0)
601                                 dev_warn(&adapter->dev, "Ignoring 'force' "
602                                         "parameter for unknown chip at "
603                                         "adapter %d, address 0x%02x\n",
604                                         i2c_adapter_id(adapter), address);
605                         goto err_nodev;
606                 }
607
608                 if (lm78_alias_detect(client, i)) {
609                         dev_dbg(&adapter->dev, "Device at 0x%02x appears to "
610                                 "be the same as ISA device\n", address);
611                         goto err_nodev;
612                 }
613         }
614
615         if (isa)
616                 mutex_unlock(&isa->update_lock);
617
618         switch (kind) {
619         case lm79:
620                 client_name = "lm79";
621                 break;
622         default:
623                 client_name = "lm78";
624         }
625         strlcpy(info->type, client_name, I2C_NAME_SIZE);
626
627         return 0;
628
629  err_nodev:
630         if (isa)
631                 mutex_unlock(&isa->update_lock);
632         return -ENODEV;
633 }
634
635 static int lm78_i2c_probe(struct i2c_client *client,
636                           const struct i2c_device_id *id)
637 {
638         struct lm78_data *data;
639         int err;
640
641         data = kzalloc(sizeof(struct lm78_data), GFP_KERNEL);
642         if (!data)
643                 return -ENOMEM;
644
645         i2c_set_clientdata(client, data);
646         data->client = client;
647         data->type = id->driver_data;
648
649         /* Initialize the LM78 chip */
650         lm78_init_device(data);
651
652         /* Register sysfs hooks */
653         err = sysfs_create_group(&client->dev.kobj, &lm78_group);
654         if (err)
655                 goto ERROR3;
656
657         data->hwmon_dev = hwmon_device_register(&client->dev);
658         if (IS_ERR(data->hwmon_dev)) {
659                 err = PTR_ERR(data->hwmon_dev);
660                 goto ERROR4;
661         }
662
663         return 0;
664
665 ERROR4:
666         sysfs_remove_group(&client->dev.kobj, &lm78_group);
667 ERROR3:
668         kfree(data);
669         return err;
670 }
671
672 static int lm78_i2c_remove(struct i2c_client *client)
673 {
674         struct lm78_data *data = i2c_get_clientdata(client);
675
676         hwmon_device_unregister(data->hwmon_dev);
677         sysfs_remove_group(&client->dev.kobj, &lm78_group);
678         kfree(data);
679
680         return 0;
681 }
682
683 static int __devinit lm78_isa_probe(struct platform_device *pdev)
684 {
685         int err;
686         struct lm78_data *data;
687         struct resource *res;
688
689         /* Reserve the ISA region */
690         res = platform_get_resource(pdev, IORESOURCE_IO, 0);
691         if (!request_region(res->start + LM78_ADDR_REG_OFFSET, 2, "lm78")) {
692                 err = -EBUSY;
693                 goto exit;
694         }
695
696         if (!(data = kzalloc(sizeof(struct lm78_data), GFP_KERNEL))) {
697                 err = -ENOMEM;
698                 goto exit_release_region;
699         }
700         mutex_init(&data->lock);
701         data->isa_addr = res->start;
702         platform_set_drvdata(pdev, data);
703
704         if (lm78_read_value(data, LM78_REG_CHIPID) & 0x80) {
705                 data->type = lm79;
706                 data->name = "lm79";
707         } else {
708                 data->type = lm78;
709                 data->name = "lm78";
710         }
711
712         /* Initialize the LM78 chip */
713         lm78_init_device(data);
714
715         /* Register sysfs hooks */
716         if ((err = sysfs_create_group(&pdev->dev.kobj, &lm78_group))
717          || (err = device_create_file(&pdev->dev, &dev_attr_name)))
718                 goto exit_remove_files;
719
720         data->hwmon_dev = hwmon_device_register(&pdev->dev);
721         if (IS_ERR(data->hwmon_dev)) {
722                 err = PTR_ERR(data->hwmon_dev);
723                 goto exit_remove_files;
724         }
725
726         return 0;
727
728  exit_remove_files:
729         sysfs_remove_group(&pdev->dev.kobj, &lm78_group);
730         device_remove_file(&pdev->dev, &dev_attr_name);
731         kfree(data);
732  exit_release_region:
733         release_region(res->start + LM78_ADDR_REG_OFFSET, 2);
734  exit:
735         return err;
736 }
737
738 static int __devexit lm78_isa_remove(struct platform_device *pdev)
739 {
740         struct lm78_data *data = platform_get_drvdata(pdev);
741         struct resource *res;
742
743         hwmon_device_unregister(data->hwmon_dev);
744         sysfs_remove_group(&pdev->dev.kobj, &lm78_group);
745         device_remove_file(&pdev->dev, &dev_attr_name);
746         kfree(data);
747
748         res = platform_get_resource(pdev, IORESOURCE_IO, 0);
749         release_region(res->start + LM78_ADDR_REG_OFFSET, 2);
750
751         return 0;
752 }
753
754 /* The SMBus locks itself, but ISA access must be locked explicitly! 
755    We don't want to lock the whole ISA bus, so we lock each client
756    separately.
757    We ignore the LM78 BUSY flag at this moment - it could lead to deadlocks,
758    would slow down the LM78 access and should not be necessary.  */
759 static int lm78_read_value(struct lm78_data *data, u8 reg)
760 {
761         struct i2c_client *client = data->client;
762
763         if (!client) { /* ISA device */
764                 int res;
765                 mutex_lock(&data->lock);
766                 outb_p(reg, data->isa_addr + LM78_ADDR_REG_OFFSET);
767                 res = inb_p(data->isa_addr + LM78_DATA_REG_OFFSET);
768                 mutex_unlock(&data->lock);
769                 return res;
770         } else
771                 return i2c_smbus_read_byte_data(client, reg);
772 }
773
774 /* The SMBus locks itself, but ISA access muse be locked explicitly! 
775    We don't want to lock the whole ISA bus, so we lock each client
776    separately.
777    We ignore the LM78 BUSY flag at this moment - it could lead to deadlocks,
778    would slow down the LM78 access and should not be necessary. 
779    There are some ugly typecasts here, but the good new is - they should
780    nowhere else be necessary! */
781 static int lm78_write_value(struct lm78_data *data, u8 reg, u8 value)
782 {
783         struct i2c_client *client = data->client;
784
785         if (!client) { /* ISA device */
786                 mutex_lock(&data->lock);
787                 outb_p(reg, data->isa_addr + LM78_ADDR_REG_OFFSET);
788                 outb_p(value, data->isa_addr + LM78_DATA_REG_OFFSET);
789                 mutex_unlock(&data->lock);
790                 return 0;
791         } else
792                 return i2c_smbus_write_byte_data(client, reg, value);
793 }
794
795 static void lm78_init_device(struct lm78_data *data)
796 {
797         u8 config;
798         int i;
799
800         /* Start monitoring */
801         config = lm78_read_value(data, LM78_REG_CONFIG);
802         if ((config & 0x09) != 0x01)
803                 lm78_write_value(data, LM78_REG_CONFIG,
804                                  (config & 0xf7) | 0x01);
805
806         /* A few vars need to be filled upon startup */
807         for (i = 0; i < 3; i++) {
808                 data->fan_min[i] = lm78_read_value(data,
809                                         LM78_REG_FAN_MIN(i));
810         }
811
812         mutex_init(&data->update_lock);
813 }
814
815 static struct lm78_data *lm78_update_device(struct device *dev)
816 {
817         struct lm78_data *data = dev_get_drvdata(dev);
818         int i;
819
820         mutex_lock(&data->update_lock);
821
822         if (time_after(jiffies, data->last_updated + HZ + HZ / 2)
823             || !data->valid) {
824
825                 dev_dbg(dev, "Starting lm78 update\n");
826
827                 for (i = 0; i <= 6; i++) {
828                         data->in[i] =
829                             lm78_read_value(data, LM78_REG_IN(i));
830                         data->in_min[i] =
831                             lm78_read_value(data, LM78_REG_IN_MIN(i));
832                         data->in_max[i] =
833                             lm78_read_value(data, LM78_REG_IN_MAX(i));
834                 }
835                 for (i = 0; i < 3; i++) {
836                         data->fan[i] =
837                             lm78_read_value(data, LM78_REG_FAN(i));
838                         data->fan_min[i] =
839                             lm78_read_value(data, LM78_REG_FAN_MIN(i));
840                 }
841                 data->temp = lm78_read_value(data, LM78_REG_TEMP);
842                 data->temp_over =
843                     lm78_read_value(data, LM78_REG_TEMP_OVER);
844                 data->temp_hyst =
845                     lm78_read_value(data, LM78_REG_TEMP_HYST);
846                 i = lm78_read_value(data, LM78_REG_VID_FANDIV);
847                 data->vid = i & 0x0f;
848                 if (data->type == lm79)
849                         data->vid |=
850                             (lm78_read_value(data, LM78_REG_CHIPID) &
851                              0x01) << 4;
852                 else
853                         data->vid |= 0x10;
854                 data->fan_div[0] = (i >> 4) & 0x03;
855                 data->fan_div[1] = i >> 6;
856                 data->alarms = lm78_read_value(data, LM78_REG_ALARM1) +
857                     (lm78_read_value(data, LM78_REG_ALARM2) << 8);
858                 data->last_updated = jiffies;
859                 data->valid = 1;
860
861                 data->fan_div[2] = 1;
862         }
863
864         mutex_unlock(&data->update_lock);
865
866         return data;
867 }
868
869 /* return 1 if a supported chip is found, 0 otherwise */
870 static int __init lm78_isa_found(unsigned short address)
871 {
872         int val, save, found = 0;
873
874         /* We have to request the region in two parts because some
875            boards declare base+4 to base+7 as a PNP device */
876         if (!request_region(address, 4, "lm78")) {
877                 pr_debug("lm78: Failed to request low part of region\n");
878                 return 0;
879         }
880         if (!request_region(address + 4, 4, "lm78")) {
881                 pr_debug("lm78: Failed to request high part of region\n");
882                 release_region(address, 4);
883                 return 0;
884         }
885
886 #define REALLY_SLOW_IO
887         /* We need the timeouts for at least some LM78-like
888            chips. But only if we read 'undefined' registers. */
889         val = inb_p(address + 1);
890         if (inb_p(address + 2) != val
891          || inb_p(address + 3) != val
892          || inb_p(address + 7) != val)
893                 goto release;
894 #undef REALLY_SLOW_IO
895
896         /* We should be able to change the 7 LSB of the address port. The
897            MSB (busy flag) should be clear initially, set after the write. */
898         save = inb_p(address + LM78_ADDR_REG_OFFSET);
899         if (save & 0x80)
900                 goto release;
901         val = ~save & 0x7f;
902         outb_p(val, address + LM78_ADDR_REG_OFFSET);
903         if (inb_p(address + LM78_ADDR_REG_OFFSET) != (val | 0x80)) {
904                 outb_p(save, address + LM78_ADDR_REG_OFFSET);
905                 goto release;
906         }
907
908         /* We found a device, now see if it could be an LM78 */
909         outb_p(LM78_REG_CONFIG, address + LM78_ADDR_REG_OFFSET);
910         val = inb_p(address + LM78_DATA_REG_OFFSET);
911         if (val & 0x80)
912                 goto release;
913         outb_p(LM78_REG_I2C_ADDR, address + LM78_ADDR_REG_OFFSET);
914         val = inb_p(address + LM78_DATA_REG_OFFSET);
915         if (val < 0x03 || val > 0x77)   /* Not a valid I2C address */
916                 goto release;
917
918         /* The busy flag should be clear again */
919         if (inb_p(address + LM78_ADDR_REG_OFFSET) & 0x80)
920                 goto release;
921
922         /* Explicitly prevent the misdetection of Winbond chips */
923         outb_p(0x4f, address + LM78_ADDR_REG_OFFSET);
924         val = inb_p(address + LM78_DATA_REG_OFFSET);
925         if (val == 0xa3 || val == 0x5c)
926                 goto release;
927
928         /* Explicitly prevent the misdetection of ITE chips */
929         outb_p(0x58, address + LM78_ADDR_REG_OFFSET);
930         val = inb_p(address + LM78_DATA_REG_OFFSET);
931         if (val == 0x90)
932                 goto release;
933
934         /* Determine the chip type */
935         outb_p(LM78_REG_CHIPID, address + LM78_ADDR_REG_OFFSET);
936         val = inb_p(address + LM78_DATA_REG_OFFSET);
937         if (val == 0x00 || val == 0x20  /* LM78 */
938          || val == 0x40                 /* LM78-J */
939          || (val & 0xfe) == 0xc0)       /* LM79 */
940                 found = 1;
941
942         if (found)
943                 pr_info("lm78: Found an %s chip at %#x\n",
944                         val & 0x80 ? "LM79" : "LM78", (int)address);
945
946  release:
947         release_region(address + 4, 4);
948         release_region(address, 4);
949         return found;
950 }
951
952 static int __init lm78_isa_device_add(unsigned short address)
953 {
954         struct resource res = {
955                 .start  = address,
956                 .end    = address + LM78_EXTENT - 1,
957                 .name   = "lm78",
958                 .flags  = IORESOURCE_IO,
959         };
960         int err;
961
962         pdev = platform_device_alloc("lm78", address);
963         if (!pdev) {
964                 err = -ENOMEM;
965                 printk(KERN_ERR "lm78: Device allocation failed\n");
966                 goto exit;
967         }
968
969         err = platform_device_add_resources(pdev, &res, 1);
970         if (err) {
971                 printk(KERN_ERR "lm78: Device resource addition failed "
972                        "(%d)\n", err);
973                 goto exit_device_put;
974         }
975
976         err = platform_device_add(pdev);
977         if (err) {
978                 printk(KERN_ERR "lm78: Device addition failed (%d)\n",
979                        err);
980                 goto exit_device_put;
981         }
982
983         return 0;
984
985  exit_device_put:
986         platform_device_put(pdev);
987  exit:
988         pdev = NULL;
989         return err;
990 }
991
992 static int __init sm_lm78_init(void)
993 {
994         int res;
995
996         /* We register the ISA device first, so that we can skip the
997          * registration of an I2C interface to the same device. */
998         if (lm78_isa_found(isa_address)) {
999                 res = platform_driver_register(&lm78_isa_driver);
1000                 if (res)
1001                         goto exit;
1002
1003                 /* Sets global pdev as a side effect */
1004                 res = lm78_isa_device_add(isa_address);
1005                 if (res)
1006                         goto exit_unreg_isa_driver;
1007         }
1008
1009         res = i2c_add_driver(&lm78_driver);
1010         if (res)
1011                 goto exit_unreg_isa_device;
1012
1013         return 0;
1014
1015  exit_unreg_isa_device:
1016         platform_device_unregister(pdev);
1017  exit_unreg_isa_driver:
1018         platform_driver_unregister(&lm78_isa_driver);
1019  exit:
1020         return res;
1021 }
1022
1023 static void __exit sm_lm78_exit(void)
1024 {
1025         if (pdev) {
1026                 platform_device_unregister(pdev);
1027                 platform_driver_unregister(&lm78_isa_driver);
1028         }
1029         i2c_del_driver(&lm78_driver);
1030 }
1031
1032
1033
1034 MODULE_AUTHOR("Frodo Looijaard <frodol@dds.nl>");
1035 MODULE_DESCRIPTION("LM78/LM79 driver");
1036 MODULE_LICENSE("GPL");
1037
1038 module_init(sm_lm78_init);
1039 module_exit(sm_lm78_exit);