Merge branch 'release' of master.kernel.org:/home/ftp/pub/scm/linux/kernel/git/aegl...
[linux-2.6] / drivers / hwmon / fscpos.c
1 /*
2         fscpos.c - Kernel module for hardware monitoring with FSC Poseidon chips
3         Copyright (C) 2004, 2005 Stefan Ott <stefan@desire.ch>
4
5         This program is free software; you can redistribute it and/or modify
6         it under the terms of the GNU General Public License as published by
7         the Free Software Foundation; either version 2 of the License, or
8         (at your option) any later version.
9
10         This program is distributed in the hope that it will be useful,
11         but WITHOUT ANY WARRANTY; without even the implied warranty of
12         MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13         GNU General Public License for more details.
14
15         You should have received a copy of the GNU General Public License
16         along with this program; if not, write to the Free Software
17         Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
18 */
19
20 /*
21         fujitsu siemens poseidon chip,
22         module based on the old fscpos module by Hermann Jung <hej@odn.de> and
23         the fscher module by Reinhard Nissl <rnissl@gmx.de>
24
25         original module based on lm80.c
26         Copyright (C) 1998, 1999 Frodo Looijaard <frodol@dds.nl>
27         and Philip Edelbrock <phil@netroedge.com>
28
29         Thanks to Jean Delvare for reviewing my code and suggesting a lot of
30         improvements.
31 */
32
33 #include <linux/module.h>
34 #include <linux/slab.h>
35 #include <linux/jiffies.h>
36 #include <linux/i2c.h>
37 #include <linux/init.h>
38 #include <linux/hwmon.h>
39 #include <linux/err.h>
40 #include <linux/mutex.h>
41 #include <linux/sysfs.h>
42
43 /*
44  * Addresses to scan
45  */
46 static unsigned short normal_i2c[] = { 0x73, I2C_CLIENT_END };
47
48 /*
49  * Insmod parameters
50  */
51 I2C_CLIENT_INSMOD_1(fscpos);
52
53 /*
54  * The FSCPOS registers
55  */
56
57 /* chip identification */
58 #define FSCPOS_REG_IDENT_0              0x00
59 #define FSCPOS_REG_IDENT_1              0x01
60 #define FSCPOS_REG_IDENT_2              0x02
61 #define FSCPOS_REG_REVISION             0x03
62
63 /* global control and status */
64 #define FSCPOS_REG_EVENT_STATE          0x04
65 #define FSCPOS_REG_CONTROL              0x05
66
67 /* watchdog */
68 #define FSCPOS_REG_WDOG_PRESET          0x28
69 #define FSCPOS_REG_WDOG_STATE           0x23
70 #define FSCPOS_REG_WDOG_CONTROL         0x21
71
72 /* voltages */
73 #define FSCPOS_REG_VOLT_12              0x45
74 #define FSCPOS_REG_VOLT_5               0x42
75 #define FSCPOS_REG_VOLT_BATT            0x48
76
77 /* fans - the chip does not support minimum speed for fan2 */
78 static u8 FSCPOS_REG_PWM[] = { 0x55, 0x65 };
79 static u8 FSCPOS_REG_FAN_ACT[] = { 0x0e, 0x6b, 0xab };
80 static u8 FSCPOS_REG_FAN_STATE[] = { 0x0d, 0x62, 0xa2 };
81 static u8 FSCPOS_REG_FAN_RIPPLE[] = { 0x0f, 0x6f, 0xaf };
82
83 /* temperatures */
84 static u8 FSCPOS_REG_TEMP_ACT[] = { 0x64, 0x32, 0x35 };
85 static u8 FSCPOS_REG_TEMP_STATE[] = { 0x71, 0x81, 0x91 };
86
87 /*
88  * Functions declaration
89  */
90 static int fscpos_attach_adapter(struct i2c_adapter *adapter);
91 static int fscpos_detect(struct i2c_adapter *adapter, int address, int kind);
92 static int fscpos_detach_client(struct i2c_client *client);
93
94 static int fscpos_read_value(struct i2c_client *client, u8 reg);
95 static int fscpos_write_value(struct i2c_client *client, u8 reg, u8 value);
96 static struct fscpos_data *fscpos_update_device(struct device *dev);
97 static void fscpos_init_client(struct i2c_client *client);
98
99 static void reset_fan_alarm(struct i2c_client *client, int nr);
100
101 /*
102  * Driver data (common to all clients)
103  */
104 static struct i2c_driver fscpos_driver = {
105         .driver = {
106                 .name   = "fscpos",
107         },
108         .id             = I2C_DRIVERID_FSCPOS,
109         .attach_adapter = fscpos_attach_adapter,
110         .detach_client  = fscpos_detach_client,
111 };
112
113 /*
114  * Client data (each client gets its own)
115  */
116 struct fscpos_data {
117         struct i2c_client client;
118         struct class_device *class_dev;
119         struct mutex update_lock;
120         char valid;             /* 0 until following fields are valid */
121         unsigned long last_updated;     /* In jiffies */
122
123         /* register values */
124         u8 revision;            /* revision of chip */
125         u8 global_event;        /* global event status */
126         u8 global_control;      /* global control register */
127         u8 wdog_control;        /* watchdog control */
128         u8 wdog_state;          /* watchdog status */
129         u8 wdog_preset;         /* watchdog preset */
130         u8 volt[3];             /* 12, 5, battery current */
131         u8 temp_act[3];         /* temperature */
132         u8 temp_status[3];      /* status of sensor */
133         u8 fan_act[3];          /* fans revolutions per second */
134         u8 fan_status[3];       /* fan status */
135         u8 pwm[2];              /* fan min value for rps */
136         u8 fan_ripple[3];       /* divider for rps */
137 };
138
139 /* Temperature */
140 #define TEMP_FROM_REG(val)      (((val) - 128) * 1000)
141
142 static ssize_t show_temp_input(struct fscpos_data *data, char *buf, int nr)
143 {
144         return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_act[nr - 1]));
145 }
146
147 static ssize_t show_temp_status(struct fscpos_data *data, char *buf, int nr)
148 {
149         /* bits 2..7 reserved => mask with 0x03 */
150         return sprintf(buf, "%u\n", data->temp_status[nr - 1] & 0x03);
151 }
152
153 static ssize_t show_temp_reset(struct fscpos_data *data, char *buf, int nr)
154 {
155         return sprintf(buf, "1\n");
156 }
157
158 static ssize_t set_temp_reset(struct i2c_client *client, struct fscpos_data
159                         *data, const char *buf, size_t count, int nr, int reg)
160 {
161         unsigned long v = simple_strtoul(buf, NULL, 10);
162         if (v != 1) {
163                 dev_err(&client->dev, "temp_reset value %ld not supported. "
164                                         "Use 1 to reset the alarm!\n", v);
165                 return -EINVAL;
166         }
167
168         dev_info(&client->dev, "You used the temp_reset feature which has not "
169                                 "been proplerly tested. Please report your "
170                                 "experience to the module author.\n");
171
172         /* Supported value: 2 (clears the status) */
173         fscpos_write_value(client, FSCPOS_REG_TEMP_STATE[nr - 1], 2);
174         return count;
175 }
176
177 /* Fans */
178 #define RPM_FROM_REG(val)       ((val) * 60)
179
180 static ssize_t show_fan_status(struct fscpos_data *data, char *buf, int nr)
181 {
182         /* bits 0..1, 3..7 reserved => mask with 0x04 */
183         return sprintf(buf, "%u\n", data->fan_status[nr - 1] & 0x04);
184 }
185
186 static ssize_t show_fan_input(struct fscpos_data *data, char *buf, int nr)
187 {
188         return sprintf(buf, "%u\n", RPM_FROM_REG(data->fan_act[nr - 1]));
189 }
190
191 static ssize_t show_fan_ripple(struct fscpos_data *data, char *buf, int nr)
192 {
193         /* bits 2..7 reserved => mask with 0x03 */
194         return sprintf(buf, "%u\n", data->fan_ripple[nr - 1] & 0x03);
195 }
196
197 static ssize_t set_fan_ripple(struct i2c_client *client, struct fscpos_data
198                         *data, const char *buf, size_t count, int nr, int reg)
199 {
200         /* supported values: 2, 4, 8 */
201         unsigned long v = simple_strtoul(buf, NULL, 10);
202
203         switch (v) {
204                 case 2: v = 1; break;
205                 case 4: v = 2; break;
206                 case 8: v = 3; break;
207         default:
208                 dev_err(&client->dev, "fan_ripple value %ld not supported. "
209                                         "Must be one of 2, 4 or 8!\n", v);
210                 return -EINVAL;
211         }
212         
213         mutex_lock(&data->update_lock);
214         /* bits 2..7 reserved => mask with 0x03 */
215         data->fan_ripple[nr - 1] &= ~0x03;
216         data->fan_ripple[nr - 1] |= v;
217         
218         fscpos_write_value(client, reg, data->fan_ripple[nr - 1]);
219         mutex_unlock(&data->update_lock);
220         return count;
221 }
222
223 static ssize_t show_pwm(struct fscpos_data *data, char *buf, int nr)
224 {
225         return sprintf(buf, "%u\n", data->pwm[nr - 1]);
226 }
227
228 static ssize_t set_pwm(struct i2c_client *client, struct fscpos_data *data,
229                                 const char *buf, size_t count, int nr, int reg)
230 {
231         unsigned long v = simple_strtoul(buf, NULL, 10);
232
233         /* Range: 0..255 */
234         if (v < 0) v = 0;
235         if (v > 255) v = 255;
236
237         mutex_lock(&data->update_lock);
238         data->pwm[nr - 1] = v;
239         fscpos_write_value(client, reg, data->pwm[nr - 1]);
240         mutex_unlock(&data->update_lock);
241         return count;
242 }
243
244 static void reset_fan_alarm(struct i2c_client *client, int nr)
245 {
246         fscpos_write_value(client, FSCPOS_REG_FAN_STATE[nr], 4);
247 }
248
249 /* Volts */
250 #define VOLT_FROM_REG(val, mult)        ((val) * (mult) / 255)
251
252 static ssize_t show_volt_12(struct device *dev, struct device_attribute *attr, char *buf)
253 {
254         struct fscpos_data *data = fscpos_update_device(dev);
255         return sprintf(buf, "%u\n", VOLT_FROM_REG(data->volt[0], 14200));
256 }
257
258 static ssize_t show_volt_5(struct device *dev, struct device_attribute *attr, char *buf)
259 {
260         struct fscpos_data *data = fscpos_update_device(dev);
261         return sprintf(buf, "%u\n", VOLT_FROM_REG(data->volt[1], 6600));
262 }
263
264 static ssize_t show_volt_batt(struct device *dev, struct device_attribute *attr, char *buf)
265 {
266         struct fscpos_data *data = fscpos_update_device(dev);
267         return sprintf(buf, "%u\n", VOLT_FROM_REG(data->volt[2], 3300));
268 }
269
270 /* Watchdog */
271 static ssize_t show_wdog_control(struct fscpos_data *data, char *buf)
272 {
273         /* bits 0..3 reserved, bit 6 write only => mask with 0xb0 */
274         return sprintf(buf, "%u\n", data->wdog_control & 0xb0);
275 }
276
277 static ssize_t set_wdog_control(struct i2c_client *client, struct fscpos_data
278                                 *data, const char *buf, size_t count, int reg)
279 {
280         /* bits 0..3 reserved => mask with 0xf0 */
281         unsigned long v = simple_strtoul(buf, NULL, 10) & 0xf0;
282
283         mutex_lock(&data->update_lock);
284         data->wdog_control &= ~0xf0;
285         data->wdog_control |= v;
286         fscpos_write_value(client, reg, data->wdog_control);
287         mutex_unlock(&data->update_lock);
288         return count;
289 }
290
291 static ssize_t show_wdog_state(struct fscpos_data *data, char *buf)
292 {
293         /* bits 0, 2..7 reserved => mask with 0x02 */
294         return sprintf(buf, "%u\n", data->wdog_state & 0x02);
295 }
296
297 static ssize_t set_wdog_state(struct i2c_client *client, struct fscpos_data
298                                 *data, const char *buf, size_t count, int reg)
299 {
300         unsigned long v = simple_strtoul(buf, NULL, 10) & 0x02;
301
302         /* Valid values: 2 (clear) */
303         if (v != 2) {
304                 dev_err(&client->dev, "wdog_state value %ld not supported. "
305                                         "Must be 2 to clear the state!\n", v);
306                 return -EINVAL;
307         }
308
309         mutex_lock(&data->update_lock);
310         data->wdog_state &= ~v;
311         fscpos_write_value(client, reg, v);
312         mutex_unlock(&data->update_lock);
313         return count;
314 }
315
316 static ssize_t show_wdog_preset(struct fscpos_data *data, char *buf)
317 {
318         return sprintf(buf, "%u\n", data->wdog_preset);
319 }
320
321 static ssize_t set_wdog_preset(struct i2c_client *client, struct fscpos_data
322                                 *data, const char *buf, size_t count, int reg)
323 {
324         unsigned long v = simple_strtoul(buf, NULL, 10) & 0xff;
325
326         mutex_lock(&data->update_lock);
327         data->wdog_preset = v;
328         fscpos_write_value(client, reg, data->wdog_preset);
329         mutex_unlock(&data->update_lock);
330         return count;
331 }
332
333 /* Event */
334 static ssize_t show_event(struct device *dev, struct device_attribute *attr, char *buf)
335 {
336         /* bits 5..7 reserved => mask with 0x1f */
337         struct fscpos_data *data = fscpos_update_device(dev);
338         return sprintf(buf, "%u\n", data->global_event & 0x9b);
339 }
340
341 /*
342  * Sysfs stuff
343  */
344 #define create_getter(kind, sub) \
345         static ssize_t sysfs_show_##kind##sub(struct device *dev, struct device_attribute *attr, char *buf) \
346         { \
347                 struct fscpos_data *data = fscpos_update_device(dev); \
348                 return show_##kind##sub(data, buf); \
349         }
350
351 #define create_getter_n(kind, offset, sub) \
352         static ssize_t sysfs_show_##kind##offset##sub(struct device *dev, struct device_attribute *attr, char\
353                                                                         *buf) \
354         { \
355                 struct fscpos_data *data = fscpos_update_device(dev); \
356                 return show_##kind##sub(data, buf, offset); \
357         }
358
359 #define create_setter(kind, sub, reg) \
360         static ssize_t sysfs_set_##kind##sub (struct device *dev, struct device_attribute *attr, const char \
361                                                         *buf, size_t count) \
362         { \
363                 struct i2c_client *client = to_i2c_client(dev); \
364                 struct fscpos_data *data = i2c_get_clientdata(client); \
365                 return set_##kind##sub(client, data, buf, count, reg); \
366         }
367
368 #define create_setter_n(kind, offset, sub, reg) \
369         static ssize_t sysfs_set_##kind##offset##sub (struct device *dev, struct device_attribute *attr, \
370                                         const char *buf, size_t count) \
371         { \
372                 struct i2c_client *client = to_i2c_client(dev); \
373                 struct fscpos_data *data = i2c_get_clientdata(client); \
374                 return set_##kind##sub(client, data, buf, count, offset, reg);\
375         }
376
377 #define create_sysfs_device_ro(kind, sub, offset) \
378         static DEVICE_ATTR(kind##offset##sub, S_IRUGO, \
379                                         sysfs_show_##kind##offset##sub, NULL);
380
381 #define create_sysfs_device_rw(kind, sub, offset) \
382         static DEVICE_ATTR(kind##offset##sub, S_IRUGO | S_IWUSR, \
383                 sysfs_show_##kind##offset##sub, sysfs_set_##kind##offset##sub);
384
385 #define sysfs_ro_n(kind, sub, offset) \
386         create_getter_n(kind, offset, sub); \
387         create_sysfs_device_ro(kind, sub, offset);
388
389 #define sysfs_rw_n(kind, sub, offset, reg) \
390         create_getter_n(kind, offset, sub); \
391         create_setter_n(kind, offset, sub, reg); \
392         create_sysfs_device_rw(kind, sub, offset);
393
394 #define sysfs_rw(kind, sub, reg) \
395         create_getter(kind, sub); \
396         create_setter(kind, sub, reg); \
397         create_sysfs_device_rw(kind, sub,);
398
399 #define sysfs_fan_with_min(offset, reg_status, reg_ripple, reg_min) \
400         sysfs_fan(offset, reg_status, reg_ripple); \
401         sysfs_rw_n(pwm,, offset, reg_min);
402
403 #define sysfs_fan(offset, reg_status, reg_ripple) \
404         sysfs_ro_n(fan, _input, offset); \
405         sysfs_ro_n(fan, _status, offset); \
406         sysfs_rw_n(fan, _ripple, offset, reg_ripple);
407
408 #define sysfs_temp(offset, reg_status) \
409         sysfs_ro_n(temp, _input, offset); \
410         sysfs_ro_n(temp, _status, offset); \
411         sysfs_rw_n(temp, _reset, offset, reg_status);
412
413 #define sysfs_watchdog(reg_wdog_preset, reg_wdog_state, reg_wdog_control) \
414         sysfs_rw(wdog, _control, reg_wdog_control); \
415         sysfs_rw(wdog, _preset, reg_wdog_preset); \
416         sysfs_rw(wdog, _state, reg_wdog_state);
417
418 sysfs_fan_with_min(1, FSCPOS_REG_FAN_STATE[0], FSCPOS_REG_FAN_RIPPLE[0],
419                                                         FSCPOS_REG_PWM[0]);
420 sysfs_fan_with_min(2, FSCPOS_REG_FAN_STATE[1], FSCPOS_REG_FAN_RIPPLE[1],
421                                                         FSCPOS_REG_PWM[1]);
422 sysfs_fan(3, FSCPOS_REG_FAN_STATE[2], FSCPOS_REG_FAN_RIPPLE[2]);
423
424 sysfs_temp(1, FSCPOS_REG_TEMP_STATE[0]);
425 sysfs_temp(2, FSCPOS_REG_TEMP_STATE[1]);
426 sysfs_temp(3, FSCPOS_REG_TEMP_STATE[2]);
427
428 sysfs_watchdog(FSCPOS_REG_WDOG_PRESET, FSCPOS_REG_WDOG_STATE,
429                                                 FSCPOS_REG_WDOG_CONTROL);
430
431 static DEVICE_ATTR(event, S_IRUGO, show_event, NULL);
432 static DEVICE_ATTR(in0_input, S_IRUGO, show_volt_12, NULL);
433 static DEVICE_ATTR(in1_input, S_IRUGO, show_volt_5, NULL);
434 static DEVICE_ATTR(in2_input, S_IRUGO, show_volt_batt, NULL);
435
436 static struct attribute *fscpos_attributes[] = {
437         &dev_attr_event.attr,
438         &dev_attr_in0_input.attr,
439         &dev_attr_in1_input.attr,
440         &dev_attr_in2_input.attr,
441
442         &dev_attr_wdog_control.attr,
443         &dev_attr_wdog_preset.attr,
444         &dev_attr_wdog_state.attr,
445
446         &dev_attr_temp1_input.attr,
447         &dev_attr_temp1_status.attr,
448         &dev_attr_temp1_reset.attr,
449         &dev_attr_temp2_input.attr,
450         &dev_attr_temp2_status.attr,
451         &dev_attr_temp2_reset.attr,
452         &dev_attr_temp3_input.attr,
453         &dev_attr_temp3_status.attr,
454         &dev_attr_temp3_reset.attr,
455
456         &dev_attr_fan1_input.attr,
457         &dev_attr_fan1_status.attr,
458         &dev_attr_fan1_ripple.attr,
459         &dev_attr_pwm1.attr,
460         &dev_attr_fan2_input.attr,
461         &dev_attr_fan2_status.attr,
462         &dev_attr_fan2_ripple.attr,
463         &dev_attr_pwm2.attr,
464         &dev_attr_fan3_input.attr,
465         &dev_attr_fan3_status.attr,
466         &dev_attr_fan3_ripple.attr,
467         NULL
468 };
469
470 static const struct attribute_group fscpos_group = {
471         .attrs = fscpos_attributes,
472 };
473
474 static int fscpos_attach_adapter(struct i2c_adapter *adapter)
475 {
476         if (!(adapter->class & I2C_CLASS_HWMON))
477                 return 0;
478         return i2c_probe(adapter, &addr_data, fscpos_detect);
479 }
480
481 static int fscpos_detect(struct i2c_adapter *adapter, int address, int kind)
482 {
483         struct i2c_client *new_client;
484         struct fscpos_data *data;
485         int err = 0;
486
487         if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
488                 goto exit;
489
490         /*
491          * OK. For now, we presume we have a valid client. We now create the
492          * client structure, even though we cannot fill it completely yet.
493          * But it allows us to access fscpos_{read,write}_value.
494          */
495
496         if (!(data = kzalloc(sizeof(struct fscpos_data), GFP_KERNEL))) {
497                 err = -ENOMEM;
498                 goto exit;
499         }
500
501         new_client = &data->client;
502         i2c_set_clientdata(new_client, data);
503         new_client->addr = address;
504         new_client->adapter = adapter;
505         new_client->driver = &fscpos_driver;
506         new_client->flags = 0;
507
508         /* Do the remaining detection unless force or force_fscpos parameter */
509         if (kind < 0) {
510                 if ((fscpos_read_value(new_client, FSCPOS_REG_IDENT_0)
511                         != 0x50) /* 'P' */
512                 || (fscpos_read_value(new_client, FSCPOS_REG_IDENT_1)
513                         != 0x45) /* 'E' */
514                 || (fscpos_read_value(new_client, FSCPOS_REG_IDENT_2)
515                         != 0x47))/* 'G' */
516                 {
517                         dev_dbg(&new_client->dev, "fscpos detection failed\n");
518                         goto exit_free;
519                 }
520         }
521
522         /* Fill in the remaining client fields and put it in the global list */
523         strlcpy(new_client->name, "fscpos", I2C_NAME_SIZE);
524
525         data->valid = 0;
526         mutex_init(&data->update_lock);
527
528         /* Tell the I2C layer a new client has arrived */
529         if ((err = i2c_attach_client(new_client)))
530                 goto exit_free;
531
532         /* Inizialize the fscpos chip */
533         fscpos_init_client(new_client);
534
535         /* Announce that the chip was found */
536         dev_info(&new_client->dev, "Found fscpos chip, rev %u\n", data->revision);
537
538         /* Register sysfs hooks */
539         if ((err = sysfs_create_group(&new_client->dev.kobj, &fscpos_group)))
540                 goto exit_detach;
541
542         data->class_dev = hwmon_device_register(&new_client->dev);
543         if (IS_ERR(data->class_dev)) {
544                 err = PTR_ERR(data->class_dev);
545                 goto exit_remove_files;
546         }
547
548         return 0;
549
550 exit_remove_files:
551         sysfs_remove_group(&new_client->dev.kobj, &fscpos_group);
552 exit_detach:
553         i2c_detach_client(new_client);
554 exit_free:
555         kfree(data);
556 exit:
557         return err;
558 }
559
560 static int fscpos_detach_client(struct i2c_client *client)
561 {
562         struct fscpos_data *data = i2c_get_clientdata(client);
563         int err;
564
565         hwmon_device_unregister(data->class_dev);
566         sysfs_remove_group(&client->dev.kobj, &fscpos_group);
567
568         if ((err = i2c_detach_client(client)))
569                 return err;
570         kfree(data);
571         return 0;
572 }
573
574 static int fscpos_read_value(struct i2c_client *client, u8 reg)
575 {
576         dev_dbg(&client->dev, "Read reg 0x%02x\n", reg);
577         return i2c_smbus_read_byte_data(client, reg);
578 }
579
580 static int fscpos_write_value(struct i2c_client *client, u8 reg, u8 value)
581 {
582         dev_dbg(&client->dev, "Write reg 0x%02x, val 0x%02x\n", reg, value);
583         return i2c_smbus_write_byte_data(client, reg, value);
584 }
585
586 /* Called when we have found a new FSCPOS chip */
587 static void fscpos_init_client(struct i2c_client *client)
588 {
589         struct fscpos_data *data = i2c_get_clientdata(client);
590
591         /* read revision from chip */
592         data->revision = fscpos_read_value(client, FSCPOS_REG_REVISION);
593 }
594
595 static struct fscpos_data *fscpos_update_device(struct device *dev)
596 {
597         struct i2c_client *client = to_i2c_client(dev);
598         struct fscpos_data *data = i2c_get_clientdata(client);
599
600         mutex_lock(&data->update_lock);
601
602         if (time_after(jiffies, data->last_updated + 2 * HZ) || !data->valid) {
603                 int i;
604
605                 dev_dbg(&client->dev, "Starting fscpos update\n");
606
607                 for (i = 0; i < 3; i++) {
608                         data->temp_act[i] = fscpos_read_value(client,
609                                                 FSCPOS_REG_TEMP_ACT[i]);
610                         data->temp_status[i] = fscpos_read_value(client,
611                                                 FSCPOS_REG_TEMP_STATE[i]);
612                         data->fan_act[i] = fscpos_read_value(client,
613                                                 FSCPOS_REG_FAN_ACT[i]);
614                         data->fan_status[i] = fscpos_read_value(client,
615                                                 FSCPOS_REG_FAN_STATE[i]);
616                         data->fan_ripple[i] = fscpos_read_value(client,
617                                                 FSCPOS_REG_FAN_RIPPLE[i]);
618                         if (i < 2) {
619                                 /* fan2_min is not supported by the chip */
620                                 data->pwm[i] = fscpos_read_value(client,
621                                                         FSCPOS_REG_PWM[i]);
622                         }
623                         /* reset fan status if speed is back to > 0 */
624                         if (data->fan_status[i] != 0 && data->fan_act[i] > 0) {
625                                 reset_fan_alarm(client, i);
626                         }
627                 }
628
629                 data->volt[0] = fscpos_read_value(client, FSCPOS_REG_VOLT_12);
630                 data->volt[1] = fscpos_read_value(client, FSCPOS_REG_VOLT_5);
631                 data->volt[2] = fscpos_read_value(client, FSCPOS_REG_VOLT_BATT);
632
633                 data->wdog_preset = fscpos_read_value(client,
634                                                         FSCPOS_REG_WDOG_PRESET);
635                 data->wdog_state = fscpos_read_value(client,
636                                                         FSCPOS_REG_WDOG_STATE);
637                 data->wdog_control = fscpos_read_value(client,
638                                                 FSCPOS_REG_WDOG_CONTROL);
639
640                 data->global_event = fscpos_read_value(client,
641                                                 FSCPOS_REG_EVENT_STATE);
642
643                 data->last_updated = jiffies;
644                 data->valid = 1;
645         }
646         mutex_unlock(&data->update_lock);
647         return data;
648 }
649
650 static int __init sm_fscpos_init(void)
651 {
652         return i2c_add_driver(&fscpos_driver);
653 }
654
655 static void __exit sm_fscpos_exit(void)
656 {
657         i2c_del_driver(&fscpos_driver);
658 }
659
660 MODULE_AUTHOR("Stefan Ott <stefan@desire.ch> based on work from Hermann Jung "
661                                 "<hej@odn.de>, Frodo Looijaard <frodol@dds.nl>"
662                                 " and Philip Edelbrock <phil@netroedge.com>");
663 MODULE_DESCRIPTION("fujitsu siemens poseidon chip driver");
664 MODULE_LICENSE("GPL");
665
666 module_init(sm_fscpos_init);
667 module_exit(sm_fscpos_exit);