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