Merge master.kernel.org:/pub/scm/linux/kernel/git/dtor/input
[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
6     This program is free software; you can redistribute it and/or modify
7     it under the terms of the GNU General Public License as published by
8     the Free Software Foundation; either version 2 of the License, or
9     (at your option) any later version.
10
11     This program is distributed in the hope that it will be useful,
12     but WITHOUT ANY WARRANTY; without even the implied warranty of
13     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14     GNU General Public License for more details.
15
16     You should have received a copy of the GNU General Public License
17     along with this program; if not, write to the Free Software
18     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
19 */
20
21 #include <linux/module.h>
22 #include <linux/init.h>
23 #include <linux/slab.h>
24 #include <linux/jiffies.h>
25 #include <linux/i2c.h>
26 #include <linux/i2c-sensor.h>
27 #include <asm/io.h>
28
29 /* Addresses to scan */
30 static unsigned short normal_i2c[] = { 0x20, 0x21, 0x22, 0x23, 0x24,
31                                         0x25, 0x26, 0x27, 0x28, 0x29,
32                                         0x2a, 0x2b, 0x2c, 0x2d, 0x2e,
33                                         0x2f, I2C_CLIENT_END };
34 static unsigned int normal_isa[] = { 0x0290, I2C_CLIENT_ISA_END };
35
36 /* Insmod parameters */
37 SENSORS_INSMOD_3(lm78, lm78j, lm79);
38
39 /* Many LM78 constants specified below */
40
41 /* Length of ISA address segment */
42 #define LM78_EXTENT 8
43
44 /* Where are the ISA address/data registers relative to the base address */
45 #define LM78_ADDR_REG_OFFSET 5
46 #define LM78_DATA_REG_OFFSET 6
47
48 /* The LM78 registers */
49 #define LM78_REG_IN_MAX(nr) (0x2b + (nr) * 2)
50 #define LM78_REG_IN_MIN(nr) (0x2c + (nr) * 2)
51 #define LM78_REG_IN(nr) (0x20 + (nr))
52
53 #define LM78_REG_FAN_MIN(nr) (0x3b + (nr))
54 #define LM78_REG_FAN(nr) (0x28 + (nr))
55
56 #define LM78_REG_TEMP 0x27
57 #define LM78_REG_TEMP_OVER 0x39
58 #define LM78_REG_TEMP_HYST 0x3a
59
60 #define LM78_REG_ALARM1 0x41
61 #define LM78_REG_ALARM2 0x42
62
63 #define LM78_REG_VID_FANDIV 0x47
64
65 #define LM78_REG_CONFIG 0x40
66 #define LM78_REG_CHIPID 0x49
67 #define LM78_REG_I2C_ADDR 0x48
68
69
70 /* Conversions. Rounding and limit checking is only done on the TO_REG 
71    variants. */
72
73 /* IN: mV, (0V to 4.08V)
74    REG: 16mV/bit */
75 static inline u8 IN_TO_REG(unsigned long val)
76 {
77         unsigned long nval = SENSORS_LIMIT(val, 0, 4080);
78         return (nval + 8) / 16;
79 }
80 #define IN_FROM_REG(val) ((val) *  16)
81
82 static inline u8 FAN_TO_REG(long rpm, int div)
83 {
84         if (rpm <= 0)
85                 return 255;
86         return SENSORS_LIMIT((1350000 + rpm * div / 2) / (rpm * div), 1, 254);
87 }
88
89 static inline int FAN_FROM_REG(u8 val, int div)
90 {
91         return val==0 ? -1 : val==255 ? 0 : 1350000/(val*div);
92 }
93
94 /* TEMP: mC (-128C to +127C)
95    REG: 1C/bit, two's complement */
96 static inline s8 TEMP_TO_REG(int val)
97 {
98         int nval = SENSORS_LIMIT(val, -128000, 127000) ;
99         return nval<0 ? (nval-500)/1000 : (nval+500)/1000;
100 }
101
102 static inline int TEMP_FROM_REG(s8 val)
103 {
104         return val * 1000;
105 }
106
107 /* VID: mV
108    REG: (see doc/vid) */
109 static inline int VID_FROM_REG(u8 val)
110 {
111         return val==0x1f ? 0 : val>=0x10 ? 5100-val*100 : 2050-val*50;
112 }
113
114 #define DIV_FROM_REG(val) (1 << (val))
115
116 /* There are some complications in a module like this. First off, LM78 chips
117    may be both present on the SMBus and the ISA bus, and we have to handle
118    those cases separately at some places. Second, there might be several
119    LM78 chips available (well, actually, that is probably never done; but
120    it is a clean illustration of how to handle a case like that). Finally,
121    a specific chip may be attached to *both* ISA and SMBus, and we would
122    not like to detect it double. Fortunately, in the case of the LM78 at
123    least, a register tells us what SMBus address we are on, so that helps
124    a bit - except if there could be more than one SMBus. Groan. No solution
125    for this yet. */
126
127 /* This module may seem overly long and complicated. In fact, it is not so
128    bad. Quite a lot of bookkeeping is done. A real driver can often cut
129    some corners. */
130
131 /* For each registered LM78, we need to keep some data in memory. That
132    data is pointed to by lm78_list[NR]->data. The structure itself is
133    dynamically allocated, at the same time when a new lm78 client is
134    allocated. */
135 struct lm78_data {
136         struct i2c_client client;
137         struct semaphore lock;
138         enum chips type;
139
140         struct semaphore update_lock;
141         char valid;             /* !=0 if following fields are valid */
142         unsigned long last_updated;     /* In jiffies */
143
144         u8 in[7];               /* Register value */
145         u8 in_max[7];           /* Register value */
146         u8 in_min[7];           /* Register value */
147         u8 fan[3];              /* Register value */
148         u8 fan_min[3];          /* Register value */
149         s8 temp;                /* Register value */
150         s8 temp_over;           /* Register value */
151         s8 temp_hyst;           /* Register value */
152         u8 fan_div[3];          /* Register encoding, shifted right */
153         u8 vid;                 /* Register encoding, combined */
154         u16 alarms;             /* Register encoding, combined */
155 };
156
157
158 static int lm78_attach_adapter(struct i2c_adapter *adapter);
159 static int lm78_detect(struct i2c_adapter *adapter, int address, int kind);
160 static int lm78_detach_client(struct i2c_client *client);
161
162 static int lm78_read_value(struct i2c_client *client, u8 register);
163 static int lm78_write_value(struct i2c_client *client, u8 register, u8 value);
164 static struct lm78_data *lm78_update_device(struct device *dev);
165 static void lm78_init_client(struct i2c_client *client);
166
167
168 static struct i2c_driver lm78_driver = {
169         .owner          = THIS_MODULE,
170         .name           = "lm78",
171         .id             = I2C_DRIVERID_LM78,
172         .flags          = I2C_DF_NOTIFY,
173         .attach_adapter = lm78_attach_adapter,
174         .detach_client  = lm78_detach_client,
175 };
176
177 /* 7 Voltages */
178 static ssize_t show_in(struct device *dev, char *buf, int nr)
179 {
180         struct lm78_data *data = lm78_update_device(dev);
181         return sprintf(buf, "%d\n", IN_FROM_REG(data->in[nr]));
182 }
183
184 static ssize_t show_in_min(struct device *dev, char *buf, int nr)
185 {
186         struct lm78_data *data = lm78_update_device(dev);
187         return sprintf(buf, "%d\n", IN_FROM_REG(data->in_min[nr]));
188 }
189
190 static ssize_t show_in_max(struct device *dev, char *buf, int nr)
191 {
192         struct lm78_data *data = lm78_update_device(dev);
193         return sprintf(buf, "%d\n", IN_FROM_REG(data->in_max[nr]));
194 }
195
196 static ssize_t set_in_min(struct device *dev, const char *buf,
197                 size_t count, int nr)
198 {
199         struct i2c_client *client = to_i2c_client(dev);
200         struct lm78_data *data = i2c_get_clientdata(client);
201         unsigned long val = simple_strtoul(buf, NULL, 10);
202
203         down(&data->update_lock);
204         data->in_min[nr] = IN_TO_REG(val);
205         lm78_write_value(client, LM78_REG_IN_MIN(nr), data->in_min[nr]);
206         up(&data->update_lock);
207         return count;
208 }
209
210 static ssize_t set_in_max(struct device *dev, const char *buf,
211                 size_t count, int nr)
212 {
213         struct i2c_client *client = to_i2c_client(dev);
214         struct lm78_data *data = i2c_get_clientdata(client);
215         unsigned long val = simple_strtoul(buf, NULL, 10);
216
217         down(&data->update_lock);
218         data->in_max[nr] = IN_TO_REG(val);
219         lm78_write_value(client, LM78_REG_IN_MAX(nr), data->in_max[nr]);
220         up(&data->update_lock);
221         return count;
222 }
223         
224 #define show_in_offset(offset)                                  \
225 static ssize_t                                                  \
226         show_in##offset (struct device *dev, struct device_attribute *attr, char *buf)          \
227 {                                                               \
228         return show_in(dev, buf, offset);                       \
229 }                                                               \
230 static DEVICE_ATTR(in##offset##_input, S_IRUGO,                 \
231                 show_in##offset, NULL);                         \
232 static ssize_t                                                  \
233         show_in##offset##_min (struct device *dev, struct device_attribute *attr, char *buf)   \
234 {                                                               \
235         return show_in_min(dev, buf, offset);                   \
236 }                                                               \
237 static ssize_t                                                  \
238         show_in##offset##_max (struct device *dev, struct device_attribute *attr, char *buf)   \
239 {                                                               \
240         return show_in_max(dev, buf, offset);                   \
241 }                                                               \
242 static ssize_t set_in##offset##_min (struct device *dev, struct device_attribute *attr, \
243                 const char *buf, size_t count)                  \
244 {                                                               \
245         return set_in_min(dev, buf, count, offset);             \
246 }                                                               \
247 static ssize_t set_in##offset##_max (struct device *dev, struct device_attribute *attr, \
248                 const char *buf, size_t count)                  \
249 {                                                               \
250         return set_in_max(dev, buf, count, offset);             \
251 }                                                               \
252 static DEVICE_ATTR(in##offset##_min, S_IRUGO | S_IWUSR,         \
253                 show_in##offset##_min, set_in##offset##_min);   \
254 static DEVICE_ATTR(in##offset##_max, S_IRUGO | S_IWUSR,         \
255                 show_in##offset##_max, set_in##offset##_max);
256
257 show_in_offset(0);
258 show_in_offset(1);
259 show_in_offset(2);
260 show_in_offset(3);
261 show_in_offset(4);
262 show_in_offset(5);
263 show_in_offset(6);
264
265 /* Temperature */
266 static ssize_t show_temp(struct device *dev, struct device_attribute *attr, char *buf)
267 {
268         struct lm78_data *data = lm78_update_device(dev);
269         return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp));
270 }
271
272 static ssize_t show_temp_over(struct device *dev, struct device_attribute *attr, char *buf)
273 {
274         struct lm78_data *data = lm78_update_device(dev);
275         return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_over));
276 }
277
278 static ssize_t set_temp_over(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
279 {
280         struct i2c_client *client = to_i2c_client(dev);
281         struct lm78_data *data = i2c_get_clientdata(client);
282         long val = simple_strtol(buf, NULL, 10);
283
284         down(&data->update_lock);
285         data->temp_over = TEMP_TO_REG(val);
286         lm78_write_value(client, LM78_REG_TEMP_OVER, data->temp_over);
287         up(&data->update_lock);
288         return count;
289 }
290
291 static ssize_t show_temp_hyst(struct device *dev, struct device_attribute *attr, char *buf)
292 {
293         struct lm78_data *data = lm78_update_device(dev);
294         return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_hyst));
295 }
296
297 static ssize_t set_temp_hyst(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
298 {
299         struct i2c_client *client = to_i2c_client(dev);
300         struct lm78_data *data = i2c_get_clientdata(client);
301         long val = simple_strtol(buf, NULL, 10);
302
303         down(&data->update_lock);
304         data->temp_hyst = TEMP_TO_REG(val);
305         lm78_write_value(client, LM78_REG_TEMP_HYST, data->temp_hyst);
306         up(&data->update_lock);
307         return count;
308 }
309
310 static DEVICE_ATTR(temp1_input, S_IRUGO, show_temp, NULL);
311 static DEVICE_ATTR(temp1_max, S_IRUGO | S_IWUSR,
312                 show_temp_over, set_temp_over);
313 static DEVICE_ATTR(temp1_max_hyst, S_IRUGO | S_IWUSR,
314                 show_temp_hyst, set_temp_hyst);
315
316 /* 3 Fans */
317 static ssize_t show_fan(struct device *dev, char *buf, int nr)
318 {
319         struct lm78_data *data = lm78_update_device(dev);
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, char *buf, int nr)
325 {
326         struct lm78_data *data = lm78_update_device(dev);
327         return sprintf(buf,"%d\n", FAN_FROM_REG(data->fan_min[nr],
328                 DIV_FROM_REG(data->fan_div[nr])) );
329 }
330
331 static ssize_t set_fan_min(struct device *dev, const char *buf,
332                 size_t count, int nr)
333 {
334         struct i2c_client *client = to_i2c_client(dev);
335         struct lm78_data *data = i2c_get_clientdata(client);
336         unsigned long val = simple_strtoul(buf, NULL, 10);
337
338         down(&data->update_lock);
339         data->fan_min[nr] = FAN_TO_REG(val, DIV_FROM_REG(data->fan_div[nr]));
340         lm78_write_value(client, LM78_REG_FAN_MIN(nr), data->fan_min[nr]);
341         up(&data->update_lock);
342         return count;
343 }
344
345 static ssize_t show_fan_div(struct device *dev, char *buf, int nr)
346 {
347         struct lm78_data *data = lm78_update_device(dev);
348         return sprintf(buf, "%d\n", DIV_FROM_REG(data->fan_div[nr]) );
349 }
350
351 /* Note: we save and restore the fan minimum here, because its value is
352    determined in part by the fan divisor.  This follows the principle of
353    least suprise; the user doesn't expect the fan minimum to change just
354    because the divisor changed. */
355 static ssize_t set_fan_div(struct device *dev, const char *buf,
356         size_t count, int nr)
357 {
358         struct i2c_client *client = to_i2c_client(dev);
359         struct lm78_data *data = i2c_get_clientdata(client);
360         unsigned long val = simple_strtoul(buf, NULL, 10);
361         unsigned long min;
362         u8 reg;
363
364         down(&data->update_lock);
365         min = FAN_FROM_REG(data->fan_min[nr],
366                            DIV_FROM_REG(data->fan_div[nr]));
367
368         switch (val) {
369         case 1: data->fan_div[nr] = 0; break;
370         case 2: data->fan_div[nr] = 1; break;
371         case 4: data->fan_div[nr] = 2; break;
372         case 8: data->fan_div[nr] = 3; break;
373         default:
374                 dev_err(&client->dev, "fan_div value %ld not "
375                         "supported. Choose one of 1, 2, 4 or 8!\n", val);
376                 up(&data->update_lock);
377                 return -EINVAL;
378         }
379
380         reg = lm78_read_value(client, LM78_REG_VID_FANDIV);
381         switch (nr) {
382         case 0:
383                 reg = (reg & 0xcf) | (data->fan_div[nr] << 4);
384                 break;
385         case 1:
386                 reg = (reg & 0x3f) | (data->fan_div[nr] << 6);
387                 break;
388         }
389         lm78_write_value(client, LM78_REG_VID_FANDIV, reg);
390
391         data->fan_min[nr] =
392                 FAN_TO_REG(min, DIV_FROM_REG(data->fan_div[nr]));
393         lm78_write_value(client, LM78_REG_FAN_MIN(nr), data->fan_min[nr]);
394         up(&data->update_lock);
395
396         return count;
397 }
398
399 #define show_fan_offset(offset)                                         \
400 static ssize_t show_fan_##offset (struct device *dev, struct device_attribute *attr, char *buf) \
401 {                                                                       \
402         return show_fan(dev, buf, offset - 1);                          \
403 }                                                                       \
404 static ssize_t show_fan_##offset##_min (struct device *dev, struct device_attribute *attr, char *buf)  \
405 {                                                                       \
406         return show_fan_min(dev, buf, offset - 1);                      \
407 }                                                                       \
408 static ssize_t show_fan_##offset##_div (struct device *dev, struct device_attribute *attr, char *buf)  \
409 {                                                                       \
410         return show_fan_div(dev, buf, offset - 1);                      \
411 }                                                                       \
412 static ssize_t set_fan_##offset##_min (struct device *dev, struct device_attribute *attr,               \
413                 const char *buf, size_t count)                          \
414 {                                                                       \
415         return set_fan_min(dev, buf, count, offset - 1);                \
416 }                                                                       \
417 static DEVICE_ATTR(fan##offset##_input, S_IRUGO, show_fan_##offset, NULL);\
418 static DEVICE_ATTR(fan##offset##_min, S_IRUGO | S_IWUSR,                \
419                 show_fan_##offset##_min, set_fan_##offset##_min);
420
421 static ssize_t set_fan_1_div(struct device *dev, struct device_attribute *attr, const char *buf,
422                 size_t count)
423 {
424         return set_fan_div(dev, buf, count, 0) ;
425 }
426
427 static ssize_t set_fan_2_div(struct device *dev, struct device_attribute *attr, const char *buf,
428                 size_t count)
429 {
430         return set_fan_div(dev, buf, count, 1) ;
431 }
432
433 show_fan_offset(1);
434 show_fan_offset(2);
435 show_fan_offset(3);
436
437 /* Fan 3 divisor is locked in H/W */
438 static DEVICE_ATTR(fan1_div, S_IRUGO | S_IWUSR,
439                 show_fan_1_div, set_fan_1_div);
440 static DEVICE_ATTR(fan2_div, S_IRUGO | S_IWUSR,
441                 show_fan_2_div, set_fan_2_div);
442 static DEVICE_ATTR(fan3_div, S_IRUGO, show_fan_3_div, NULL);
443
444 /* VID */
445 static ssize_t show_vid(struct device *dev, struct device_attribute *attr, char *buf)
446 {
447         struct lm78_data *data = lm78_update_device(dev);
448         return sprintf(buf, "%d\n", VID_FROM_REG(data->vid));
449 }
450 static DEVICE_ATTR(cpu0_vid, S_IRUGO, show_vid, NULL);
451
452 /* Alarms */
453 static ssize_t show_alarms(struct device *dev, struct device_attribute *attr, char *buf)
454 {
455         struct lm78_data *data = lm78_update_device(dev);
456         return sprintf(buf, "%u\n", data->alarms);
457 }
458 static DEVICE_ATTR(alarms, S_IRUGO, show_alarms, NULL);
459
460 /* This function is called when:
461      * lm78_driver is inserted (when this module is loaded), for each
462        available adapter
463      * when a new adapter is inserted (and lm78_driver is still present) */
464 static int lm78_attach_adapter(struct i2c_adapter *adapter)
465 {
466         if (!(adapter->class & I2C_CLASS_HWMON))
467                 return 0;
468         return i2c_detect(adapter, &addr_data, lm78_detect);
469 }
470
471 /* This function is called by i2c_detect */
472 int lm78_detect(struct i2c_adapter *adapter, int address, int kind)
473 {
474         int i, err;
475         struct i2c_client *new_client;
476         struct lm78_data *data;
477         const char *client_name = "";
478         int is_isa = i2c_is_isa_adapter(adapter);
479
480         if (!is_isa &&
481             !i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) {
482                 err = -ENODEV;
483                 goto ERROR0;
484         }
485
486         /* Reserve the ISA region */
487         if (is_isa)
488                 if (!request_region(address, LM78_EXTENT, lm78_driver.name)) {
489                         err = -EBUSY;
490                         goto ERROR0;
491                 }
492
493         /* Probe whether there is anything available on this address. Already
494            done for SMBus clients */
495         if (kind < 0) {
496                 if (is_isa) {
497
498 #define REALLY_SLOW_IO
499                         /* We need the timeouts for at least some LM78-like
500                            chips. But only if we read 'undefined' registers. */
501                         i = inb_p(address + 1);
502                         if (inb_p(address + 2) != i) {
503                                 err = -ENODEV;
504                                 goto ERROR1;
505                         }
506                         if (inb_p(address + 3) != i) {
507                                 err = -ENODEV;
508                                 goto ERROR1;
509                         }
510                         if (inb_p(address + 7) != i) {
511                                 err = -ENODEV;
512                                 goto ERROR1;
513                         }
514 #undef REALLY_SLOW_IO
515
516                         /* Let's just hope nothing breaks here */
517                         i = inb_p(address + 5) & 0x7f;
518                         outb_p(~i & 0x7f, address + 5);
519                         if ((inb_p(address + 5) & 0x7f) != (~i & 0x7f)) {
520                                 outb_p(i, address + 5);
521                                 err = -ENODEV;
522                                 goto ERROR1;
523                         }
524                 }
525         }
526
527         /* OK. For now, we presume we have a valid client. We now create the
528            client structure, even though we cannot fill it completely yet.
529            But it allows us to access lm78_{read,write}_value. */
530
531         if (!(data = kmalloc(sizeof(struct lm78_data), GFP_KERNEL))) {
532                 err = -ENOMEM;
533                 goto ERROR1;
534         }
535         memset(data, 0, sizeof(struct lm78_data));
536
537         new_client = &data->client;
538         if (is_isa)
539                 init_MUTEX(&data->lock);
540         i2c_set_clientdata(new_client, data);
541         new_client->addr = address;
542         new_client->adapter = adapter;
543         new_client->driver = &lm78_driver;
544         new_client->flags = 0;
545
546         /* Now, we do the remaining detection. */
547         if (kind < 0) {
548                 if (lm78_read_value(new_client, LM78_REG_CONFIG) & 0x80) {
549                         err = -ENODEV;
550                         goto ERROR2;
551                 }
552                 if (!is_isa && (lm78_read_value(
553                                 new_client, LM78_REG_I2C_ADDR) != address)) {
554                         err = -ENODEV;
555                         goto ERROR2;
556                 }
557         }
558
559         /* Determine the chip type. */
560         if (kind <= 0) {
561                 i = lm78_read_value(new_client, LM78_REG_CHIPID);
562                 if (i == 0x00 || i == 0x20)
563                         kind = lm78;
564                 else if (i == 0x40)
565                         kind = lm78j;
566                 else if ((i & 0xfe) == 0xc0)
567                         kind = lm79;
568                 else {
569                         if (kind == 0)
570                                 dev_warn(&adapter->dev, "Ignoring 'force' "
571                                         "parameter for unknown chip at "
572                                         "adapter %d, address 0x%02x\n",
573                                         i2c_adapter_id(adapter), address);
574                         err = -ENODEV;
575                         goto ERROR2;
576                 }
577         }
578
579         if (kind == lm78) {
580                 client_name = "lm78";
581         } else if (kind == lm78j) {
582                 client_name = "lm78-j";
583         } else if (kind == lm79) {
584                 client_name = "lm79";
585         }
586
587         /* Fill in the remaining client fields and put into the global list */
588         strlcpy(new_client->name, client_name, I2C_NAME_SIZE);
589         data->type = kind;
590
591         data->valid = 0;
592         init_MUTEX(&data->update_lock);
593
594         /* Tell the I2C layer a new client has arrived */
595         if ((err = i2c_attach_client(new_client)))
596                 goto ERROR2;
597
598         /* Initialize the LM78 chip */
599         lm78_init_client(new_client);
600
601         /* A few vars need to be filled upon startup */
602         for (i = 0; i < 3; i++) {
603                 data->fan_min[i] = lm78_read_value(new_client,
604                                         LM78_REG_FAN_MIN(i));
605         }
606
607         /* Register sysfs hooks */
608         device_create_file(&new_client->dev, &dev_attr_in0_input);
609         device_create_file(&new_client->dev, &dev_attr_in0_min);
610         device_create_file(&new_client->dev, &dev_attr_in0_max);
611         device_create_file(&new_client->dev, &dev_attr_in1_input);
612         device_create_file(&new_client->dev, &dev_attr_in1_min);
613         device_create_file(&new_client->dev, &dev_attr_in1_max);
614         device_create_file(&new_client->dev, &dev_attr_in2_input);
615         device_create_file(&new_client->dev, &dev_attr_in2_min);
616         device_create_file(&new_client->dev, &dev_attr_in2_max);
617         device_create_file(&new_client->dev, &dev_attr_in3_input);
618         device_create_file(&new_client->dev, &dev_attr_in3_min);
619         device_create_file(&new_client->dev, &dev_attr_in3_max);
620         device_create_file(&new_client->dev, &dev_attr_in4_input);
621         device_create_file(&new_client->dev, &dev_attr_in4_min);
622         device_create_file(&new_client->dev, &dev_attr_in4_max);
623         device_create_file(&new_client->dev, &dev_attr_in5_input);
624         device_create_file(&new_client->dev, &dev_attr_in5_min);
625         device_create_file(&new_client->dev, &dev_attr_in5_max);
626         device_create_file(&new_client->dev, &dev_attr_in6_input);
627         device_create_file(&new_client->dev, &dev_attr_in6_min);
628         device_create_file(&new_client->dev, &dev_attr_in6_max);
629         device_create_file(&new_client->dev, &dev_attr_temp1_input);
630         device_create_file(&new_client->dev, &dev_attr_temp1_max);
631         device_create_file(&new_client->dev, &dev_attr_temp1_max_hyst);
632         device_create_file(&new_client->dev, &dev_attr_fan1_input);
633         device_create_file(&new_client->dev, &dev_attr_fan1_min);
634         device_create_file(&new_client->dev, &dev_attr_fan1_div);
635         device_create_file(&new_client->dev, &dev_attr_fan2_input);
636         device_create_file(&new_client->dev, &dev_attr_fan2_min);
637         device_create_file(&new_client->dev, &dev_attr_fan2_div);
638         device_create_file(&new_client->dev, &dev_attr_fan3_input);
639         device_create_file(&new_client->dev, &dev_attr_fan3_min);
640         device_create_file(&new_client->dev, &dev_attr_fan3_div);
641         device_create_file(&new_client->dev, &dev_attr_alarms);
642         device_create_file(&new_client->dev, &dev_attr_cpu0_vid);
643
644         return 0;
645
646 ERROR2:
647         kfree(data);
648 ERROR1:
649         if (is_isa)
650                 release_region(address, LM78_EXTENT);
651 ERROR0:
652         return err;
653 }
654
655 static int lm78_detach_client(struct i2c_client *client)
656 {
657         int err;
658
659         if ((err = i2c_detach_client(client))) {
660                 dev_err(&client->dev,
661                     "Client deregistration failed, client not detached.\n");
662                 return err;
663         }
664
665         if(i2c_is_isa_client(client))
666                 release_region(client->addr, LM78_EXTENT);
667
668         kfree(i2c_get_clientdata(client));
669
670         return 0;
671 }
672
673 /* The SMBus locks itself, but ISA access must be locked explicitly! 
674    We don't want to lock the whole ISA bus, so we lock each client
675    separately.
676    We ignore the LM78 BUSY flag at this moment - it could lead to deadlocks,
677    would slow down the LM78 access and should not be necessary.  */
678 static int lm78_read_value(struct i2c_client *client, u8 reg)
679 {
680         int res;
681         if (i2c_is_isa_client(client)) {
682                 struct lm78_data *data = i2c_get_clientdata(client);
683                 down(&data->lock);
684                 outb_p(reg, client->addr + LM78_ADDR_REG_OFFSET);
685                 res = inb_p(client->addr + LM78_DATA_REG_OFFSET);
686                 up(&data->lock);
687                 return res;
688         } else
689                 return i2c_smbus_read_byte_data(client, reg);
690 }
691
692 /* The SMBus locks itself, but ISA access muse be locked explicitly! 
693    We don't want to lock the whole ISA bus, so we lock each client
694    separately.
695    We ignore the LM78 BUSY flag at this moment - it could lead to deadlocks,
696    would slow down the LM78 access and should not be necessary. 
697    There are some ugly typecasts here, but the good new is - they should
698    nowhere else be necessary! */
699 static int lm78_write_value(struct i2c_client *client, u8 reg, u8 value)
700 {
701         if (i2c_is_isa_client(client)) {
702                 struct lm78_data *data = i2c_get_clientdata(client);
703                 down(&data->lock);
704                 outb_p(reg, client->addr + LM78_ADDR_REG_OFFSET);
705                 outb_p(value, client->addr + LM78_DATA_REG_OFFSET);
706                 up(&data->lock);
707                 return 0;
708         } else
709                 return i2c_smbus_write_byte_data(client, reg, value);
710 }
711
712 /* Called when we have found a new LM78. It should set limits, etc. */
713 static void lm78_init_client(struct i2c_client *client)
714 {
715         u8 config = lm78_read_value(client, LM78_REG_CONFIG);
716
717         /* Start monitoring */
718         if (!(config & 0x01))
719                 lm78_write_value(client, LM78_REG_CONFIG,
720                                  (config & 0xf7) | 0x01);
721 }
722
723 static struct lm78_data *lm78_update_device(struct device *dev)
724 {
725         struct i2c_client *client = to_i2c_client(dev);
726         struct lm78_data *data = i2c_get_clientdata(client);
727         int i;
728
729         down(&data->update_lock);
730
731         if (time_after(jiffies, data->last_updated + HZ + HZ / 2)
732             || !data->valid) {
733
734                 dev_dbg(&client->dev, "Starting lm78 update\n");
735
736                 for (i = 0; i <= 6; i++) {
737                         data->in[i] =
738                             lm78_read_value(client, LM78_REG_IN(i));
739                         data->in_min[i] =
740                             lm78_read_value(client, LM78_REG_IN_MIN(i));
741                         data->in_max[i] =
742                             lm78_read_value(client, LM78_REG_IN_MAX(i));
743                 }
744                 for (i = 0; i < 3; i++) {
745                         data->fan[i] =
746                             lm78_read_value(client, LM78_REG_FAN(i));
747                         data->fan_min[i] =
748                             lm78_read_value(client, LM78_REG_FAN_MIN(i));
749                 }
750                 data->temp = lm78_read_value(client, LM78_REG_TEMP);
751                 data->temp_over =
752                     lm78_read_value(client, LM78_REG_TEMP_OVER);
753                 data->temp_hyst =
754                     lm78_read_value(client, LM78_REG_TEMP_HYST);
755                 i = lm78_read_value(client, LM78_REG_VID_FANDIV);
756                 data->vid = i & 0x0f;
757                 if (data->type == lm79)
758                         data->vid |=
759                             (lm78_read_value(client, LM78_REG_CHIPID) &
760                              0x01) << 4;
761                 else
762                         data->vid |= 0x10;
763                 data->fan_div[0] = (i >> 4) & 0x03;
764                 data->fan_div[1] = i >> 6;
765                 data->alarms = lm78_read_value(client, LM78_REG_ALARM1) +
766                     (lm78_read_value(client, LM78_REG_ALARM2) << 8);
767                 data->last_updated = jiffies;
768                 data->valid = 1;
769
770                 data->fan_div[2] = 1;
771         }
772
773         up(&data->update_lock);
774
775         return data;
776 }
777
778 static int __init sm_lm78_init(void)
779 {
780         return i2c_add_driver(&lm78_driver);
781 }
782
783 static void __exit sm_lm78_exit(void)
784 {
785         i2c_del_driver(&lm78_driver);
786 }
787
788
789
790 MODULE_AUTHOR("Frodo Looijaard <frodol@dds.nl>");
791 MODULE_DESCRIPTION("LM78, LM78-J and LM79 driver");
792 MODULE_LICENSE("GPL");
793
794 module_init(sm_lm78_init);
795 module_exit(sm_lm78_exit);