?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[CPUFREQ] checkpatch cleanups for cpufreq core
[linux-2.6/mini2440.git] / drivers / hwmon / fschmd.c
blobd07f4ef750923ca728556ed353ca6eb8ae052873
1 /* fschmd.c
2 *
3 * Copyright (C) 2007,2008 Hans de Goede <hdegoede@redhat.com>
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 * Merged Fujitsu Siemens hwmon driver, supporting the Poseidon, Hermes,
22 * Scylla, Heracles and Heimdall chips
23 *
24 * Based on the original 2.4 fscscy, 2.6 fscpos, 2.6 fscher and 2.6
25 * (candidate) fschmd drivers:
26 * Copyright (C) 2006 Thilo Cestonaro
27 * <thilo.cestonaro.external@fujitsu-siemens.com>
28 * Copyright (C) 2004, 2005 Stefan Ott <stefan@desire.ch>
29 * Copyright (C) 2003, 2004 Reinhard Nissl <rnissl@gmx.de>
30 * Copyright (c) 2001 Martin Knoblauch <mkn@teraport.de, knobi@knobisoft.de>
31 * Copyright (C) 2000 Hermann Jung <hej@odn.de>
32 */
33
34 #include <linux/module.h>
35 #include <linux/init.h>
36 #include <linux/slab.h>
37 #include <linux/jiffies.h>
38 #include <linux/i2c.h>
39 #include <linux/hwmon.h>
40 #include <linux/hwmon-sysfs.h>
41 #include <linux/err.h>
42 #include <linux/mutex.h>
43 #include <linux/sysfs.h>
44 #include <linux/dmi.h>
45 #include <linux/fs.h>
46 #include <linux/watchdog.h>
47 #include <linux/miscdevice.h>
48 #include <linux/uaccess.h>
49 #include <linux/kref.h>
50
51 /* Addresses to scan */
52 static const unsigned short normal_i2c[] = { 0x73, I2C_CLIENT_END };
53
54 /* Insmod parameters */
55 static int nowayout = WATCHDOG_NOWAYOUT;
56 module_param(nowayout, int, 0);
57 MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started (default="
58 __MODULE_STRING(WATCHDOG_NOWAYOUT) ")");
59 I2C_CLIENT_INSMOD_5(fscpos, fscher, fscscy, fschrc, fschmd);
60
61 /*
62 * The FSCHMD registers and other defines
63 */
64
65 /* chip identification */
66 #define FSCHMD_REG_IDENT_0 0x00
67 #define FSCHMD_REG_IDENT_1 0x01
68 #define FSCHMD_REG_IDENT_2 0x02
69 #define FSCHMD_REG_REVISION 0x03
70
71 /* global control and status */
72 #define FSCHMD_REG_EVENT_STATE 0x04
73 #define FSCHMD_REG_CONTROL 0x05
74
75 #define FSCHMD_CONTROL_ALERT_LED 0x01
76
77 /* watchdog */
78 #define FSCHMD_REG_WDOG_PRESET 0x28
79 #define FSCHMD_REG_WDOG_STATE 0x23
80 #define FSCHMD_REG_WDOG_CONTROL 0x21
81
82 #define FSCHMD_WDOG_CONTROL_TRIGGER 0x10
83 #define FSCHMD_WDOG_CONTROL_STARTED 0x10 /* the same as trigger */
84 #define FSCHMD_WDOG_CONTROL_STOP 0x20
85 #define FSCHMD_WDOG_CONTROL_RESOLUTION 0x40
86
87 #define FSCHMD_WDOG_STATE_CARDRESET 0x02
88
89 /* voltages, weird order is to keep the same order as the old drivers */
90 static const u8 FSCHMD_REG_VOLT[3] = { 0x45, 0x42, 0x48 };
91
92 /* minimum pwm at which the fan is driven (pwm can by increased depending on
93 the temp. Notice that for the scy some fans share there minimum speed.
94 Also notice that with the scy the sensor order is different than with the
95 other chips, this order was in the 2.4 driver and kept for consistency. */
96 static const u8 FSCHMD_REG_FAN_MIN[5][6] = {
97 { 0x55, 0x65 }, /* pos */
98 { 0x55, 0x65, 0xb5 }, /* her */
99 { 0x65, 0x65, 0x55, 0xa5, 0x55, 0xa5 }, /* scy */
100 { 0x55, 0x65, 0xa5, 0xb5 }, /* hrc */
101 { 0x55, 0x65, 0xa5, 0xb5, 0xc5 }, /* hmd */
102 };
103
104 /* actual fan speed */
105 static const u8 FSCHMD_REG_FAN_ACT[5][6] = {
106 { 0x0e, 0x6b, 0xab }, /* pos */
107 { 0x0e, 0x6b, 0xbb }, /* her */
108 { 0x6b, 0x6c, 0x0e, 0xab, 0x5c, 0xbb }, /* scy */
109 { 0x0e, 0x6b, 0xab, 0xbb }, /* hrc */
110 { 0x5b, 0x6b, 0xab, 0xbb, 0xcb }, /* hmd */
111 };
112
113 /* fan status registers */
114 static const u8 FSCHMD_REG_FAN_STATE[5][6] = {
115 { 0x0d, 0x62, 0xa2 }, /* pos */
116 { 0x0d, 0x62, 0xb2 }, /* her */
117 { 0x62, 0x61, 0x0d, 0xa2, 0x52, 0xb2 }, /* scy */
118 { 0x0d, 0x62, 0xa2, 0xb2 }, /* hrc */
119 { 0x52, 0x62, 0xa2, 0xb2, 0xc2 }, /* hmd */
120 };
121
122 /* fan ripple / divider registers */
123 static const u8 FSCHMD_REG_FAN_RIPPLE[5][6] = {
124 { 0x0f, 0x6f, 0xaf }, /* pos */
125 { 0x0f, 0x6f, 0xbf }, /* her */
126 { 0x6f, 0x6f, 0x0f, 0xaf, 0x0f, 0xbf }, /* scy */
127 { 0x0f, 0x6f, 0xaf, 0xbf }, /* hrc */
128 { 0x5f, 0x6f, 0xaf, 0xbf, 0xcf }, /* hmd */
129 };
130
131 static const int FSCHMD_NO_FAN_SENSORS[5] = { 3, 3, 6, 4, 5 };
132
133 /* Fan status register bitmasks */
134 #define FSCHMD_FAN_ALARM 0x04 /* called fault by FSC! */
135 #define FSCHMD_FAN_NOT_PRESENT 0x08 /* not documented */
136
137
138 /* actual temperature registers */
139 static const u8 FSCHMD_REG_TEMP_ACT[5][5] = {
140 { 0x64, 0x32, 0x35 }, /* pos */
141 { 0x64, 0x32, 0x35 }, /* her */
142 { 0x64, 0xD0, 0x32, 0x35 }, /* scy */
143 { 0x64, 0x32, 0x35 }, /* hrc */
144 { 0x70, 0x80, 0x90, 0xd0, 0xe0 }, /* hmd */
145 };
146
147 /* temperature state registers */
148 static const u8 FSCHMD_REG_TEMP_STATE[5][5] = {
149 { 0x71, 0x81, 0x91 }, /* pos */
150 { 0x71, 0x81, 0x91 }, /* her */
151 { 0x71, 0xd1, 0x81, 0x91 }, /* scy */
152 { 0x71, 0x81, 0x91 }, /* hrc */
153 { 0x71, 0x81, 0x91, 0xd1, 0xe1 }, /* hmd */
154 };
155
156 /* temperature high limit registers, FSC does not document these. Proven to be
157 there with field testing on the fscher and fschrc, already supported / used
158 in the fscscy 2.4 driver. FSC has confirmed that the fschmd has registers
159 at these addresses, but doesn't want to confirm they are the same as with
160 the fscher?? */
161 static const u8 FSCHMD_REG_TEMP_LIMIT[5][5] = {
162 { 0, 0, 0 }, /* pos */
163 { 0x76, 0x86, 0x96 }, /* her */
164 { 0x76, 0xd6, 0x86, 0x96 }, /* scy */
165 { 0x76, 0x86, 0x96 }, /* hrc */
166 { 0x76, 0x86, 0x96, 0xd6, 0xe6 }, /* hmd */
167 };
168
169 /* These were found through experimenting with an fscher, currently they are
170 not used, but we keep them around for future reference.
171 static const u8 FSCHER_REG_TEMP_AUTOP1[] = { 0x73, 0x83, 0x93 };
172 static const u8 FSCHER_REG_TEMP_AUTOP2[] = { 0x75, 0x85, 0x95 }; */
173
174 static const int FSCHMD_NO_TEMP_SENSORS[5] = { 3, 3, 4, 3, 5 };
175
176 /* temp status register bitmasks */
177 #define FSCHMD_TEMP_WORKING 0x01
178 #define FSCHMD_TEMP_ALERT 0x02
179 /* there only really is an alarm if the sensor is working and alert == 1 */
180 #define FSCHMD_TEMP_ALARM_MASK \
181 (FSCHMD_TEMP_WORKING | FSCHMD_TEMP_ALERT)
182
183 /*
184 * Functions declarations
185 */
186
187 static int fschmd_probe(struct i2c_client *client,
188 const struct i2c_device_id *id);
189 static int fschmd_detect(struct i2c_client *client, int kind,
190 struct i2c_board_info *info);
191 static int fschmd_remove(struct i2c_client *client);
192 static struct fschmd_data *fschmd_update_device(struct device *dev);
193
194 /*
195 * Driver data (common to all clients)
196 */
197
198 static const struct i2c_device_id fschmd_id[] = {
199 { "fscpos", fscpos },
200 { "fscher", fscher },
201 { "fscscy", fscscy },
202 { "fschrc", fschrc },
203 { "fschmd", fschmd },
204 { }
205 };
206 MODULE_DEVICE_TABLE(i2c, fschmd_id);
207
208 static struct i2c_driver fschmd_driver = {
209 .class = I2C_CLASS_HWMON,
210 .driver = {
211 .name = "fschmd",
212 },
213 .probe = fschmd_probe,
214 .remove = fschmd_remove,
215 .id_table = fschmd_id,
216 .detect = fschmd_detect,
217 .address_data = &addr_data,
218 };
219
220 /*
221 * Client data (each client gets its own)
222 */
223
224 struct fschmd_data {
225 struct i2c_client *client;
226 struct device *hwmon_dev;
227 struct mutex update_lock;
228 struct mutex watchdog_lock;
229 struct list_head list; /* member of the watchdog_data_list */
230 struct kref kref;
231 struct miscdevice watchdog_miscdev;
232 int kind;
233 unsigned long watchdog_is_open;
234 char watchdog_expect_close;
235 char watchdog_name[10]; /* must be unique to avoid sysfs conflict */
236 char valid; /* zero until following fields are valid */
237 unsigned long last_updated; /* in jiffies */
238
239 /* register values */
240 u8 revision; /* chip revision */
241 u8 global_control; /* global control register */
242 u8 watchdog_control; /* watchdog control register */
243 u8 watchdog_state; /* watchdog status register */
244 u8 watchdog_preset; /* watchdog counter preset on trigger val */
245 u8 volt[3]; /* 12, 5, battery voltage */
246 u8 temp_act[5]; /* temperature */
247 u8 temp_status[5]; /* status of sensor */
248 u8 temp_max[5]; /* high temp limit, notice: undocumented! */
249 u8 fan_act[6]; /* fans revolutions per second */
250 u8 fan_status[6]; /* fan status */
251 u8 fan_min[6]; /* fan min value for rps */
252 u8 fan_ripple[6]; /* divider for rps */
253 };
254
255 /* Global variables to hold information read from special DMI tables, which are
256 available on FSC machines with an fscher or later chip. There is no need to
257 protect these with a lock as they are only modified from our attach function
258 which always gets called with the i2c-core lock held and never accessed
259 before the attach function is done with them. */
260 static int dmi_mult[3] = { 490, 200, 100 };
261 static int dmi_offset[3] = { 0, 0, 0 };
262 static int dmi_vref = -1;
263
264 /* Somewhat ugly :( global data pointer list with all fschmd devices, so that
265 we can find our device data as when using misc_register there is no other
266 method to get to ones device data from the open fop. */
267 static LIST_HEAD(watchdog_data_list);
268 /* Note this lock not only protect list access, but also data.kref access */
269 static DEFINE_MUTEX(watchdog_data_mutex);
270
271 /* Release our data struct when we're detached from the i2c client *and* all
272 references to our watchdog device are released */
273 static void fschmd_release_resources(struct kref *ref)
274 {
275 struct fschmd_data *data = container_of(ref, struct fschmd_data, kref);
276 kfree(data);
277 }
278
279 /*
280 * Sysfs attr show / store functions
281 */
282
283 static ssize_t show_in_value(struct device *dev,
284 struct device_attribute *devattr, char *buf)
285 {
286 const int max_reading[3] = { 14200, 6600, 3300 };
287 int index = to_sensor_dev_attr(devattr)->index;
288 struct fschmd_data *data = fschmd_update_device(dev);
289
290 /* fscher / fschrc - 1 as data->kind is an array index, not a chips */
291 if (data->kind == (fscher - 1) || data->kind >= (fschrc - 1))
292 return sprintf(buf, "%d\n", (data->volt[index] * dmi_vref *
293 dmi_mult[index]) / 255 + dmi_offset[index]);
294 else
295 return sprintf(buf, "%d\n", (data->volt[index] *
296 max_reading[index] + 128) / 255);
297 }
298
299
300 #define TEMP_FROM_REG(val) (((val) - 128) * 1000)
301
302 static ssize_t show_temp_value(struct device *dev,
303 struct device_attribute *devattr, char *buf)
304 {
305 int index = to_sensor_dev_attr(devattr)->index;
306 struct fschmd_data *data = fschmd_update_device(dev);
307
308 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_act[index]));
309 }
310
311 static ssize_t show_temp_max(struct device *dev,
312 struct device_attribute *devattr, char *buf)
313 {
314 int index = to_sensor_dev_attr(devattr)->index;
315 struct fschmd_data *data = fschmd_update_device(dev);
316
317 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_max[index]));
318 }
319
320 static ssize_t store_temp_max(struct device *dev, struct device_attribute
321 *devattr, const char *buf, size_t count)
322 {
323 int index = to_sensor_dev_attr(devattr)->index;
324 struct fschmd_data *data = dev_get_drvdata(dev);
325 long v = simple_strtol(buf, NULL, 10) / 1000;
326
327 v = SENSORS_LIMIT(v, -128, 127) + 128;
328
329 mutex_lock(&data->update_lock);
330 i2c_smbus_write_byte_data(to_i2c_client(dev),
331 FSCHMD_REG_TEMP_LIMIT[data->kind][index], v);
332 data->temp_max[index] = v;
333 mutex_unlock(&data->update_lock);
334
335 return count;
336 }
337
338 static ssize_t show_temp_fault(struct device *dev,
339 struct device_attribute *devattr, char *buf)
340 {
341 int index = to_sensor_dev_attr(devattr)->index;
342 struct fschmd_data *data = fschmd_update_device(dev);
343
344 /* bit 0 set means sensor working ok, so no fault! */
345 if (data->temp_status[index] & FSCHMD_TEMP_WORKING)
346 return sprintf(buf, "0\n");
347 else
348 return sprintf(buf, "1\n");
349 }
350
351 static ssize_t show_temp_alarm(struct device *dev,
352 struct device_attribute *devattr, char *buf)
353 {
354 int index = to_sensor_dev_attr(devattr)->index;
355 struct fschmd_data *data = fschmd_update_device(dev);
356
357 if ((data->temp_status[index] & FSCHMD_TEMP_ALARM_MASK) ==
358 FSCHMD_TEMP_ALARM_MASK)
359 return sprintf(buf, "1\n");
360 else
361 return sprintf(buf, "0\n");
362 }
363
364
365 #define RPM_FROM_REG(val) ((val) * 60)
366
367 static ssize_t show_fan_value(struct device *dev,
368 struct device_attribute *devattr, char *buf)
369 {
370 int index = to_sensor_dev_attr(devattr)->index;
371 struct fschmd_data *data = fschmd_update_device(dev);
372
373 return sprintf(buf, "%u\n", RPM_FROM_REG(data->fan_act[index]));
374 }
375
376 static ssize_t show_fan_div(struct device *dev,
377 struct device_attribute *devattr, char *buf)
378 {
379 int index = to_sensor_dev_attr(devattr)->index;
380 struct fschmd_data *data = fschmd_update_device(dev);
381
382 /* bits 2..7 reserved => mask with 3 */
383 return sprintf(buf, "%d\n", 1 << (data->fan_ripple[index] & 3));
384 }
385
386 static ssize_t store_fan_div(struct device *dev, struct device_attribute
387 *devattr, const char *buf, size_t count)
388 {
389 u8 reg;
390 int index = to_sensor_dev_attr(devattr)->index;
391 struct fschmd_data *data = dev_get_drvdata(dev);
392 /* supported values: 2, 4, 8 */
393 unsigned long v = simple_strtoul(buf, NULL, 10);
394
395 switch (v) {
396 case 2: v = 1; break;
397 case 4: v = 2; break;
398 case 8: v = 3; break;
399 default:
400 dev_err(dev, "fan_div value %lu not supported. "
401 "Choose one of 2, 4 or 8!\n", v);
402 return -EINVAL;
403 }
404
405 mutex_lock(&data->update_lock);
406
407 reg = i2c_smbus_read_byte_data(to_i2c_client(dev),
408 FSCHMD_REG_FAN_RIPPLE[data->kind][index]);
409
410 /* bits 2..7 reserved => mask with 0x03 */
411 reg &= ~0x03;
412 reg |= v;
413
414 i2c_smbus_write_byte_data(to_i2c_client(dev),
415 FSCHMD_REG_FAN_RIPPLE[data->kind][index], reg);
416
417 data->fan_ripple[index] = reg;
418
419 mutex_unlock(&data->update_lock);
420
421 return count;
422 }
423
424 static ssize_t show_fan_alarm(struct device *dev,
425 struct device_attribute *devattr, char *buf)
426 {
427 int index = to_sensor_dev_attr(devattr)->index;
428 struct fschmd_data *data = fschmd_update_device(dev);
429
430 if (data->fan_status[index] & FSCHMD_FAN_ALARM)
431 return sprintf(buf, "1\n");
432 else
433 return sprintf(buf, "0\n");
434 }
435
436 static ssize_t show_fan_fault(struct device *dev,
437 struct device_attribute *devattr, char *buf)
438 {
439 int index = to_sensor_dev_attr(devattr)->index;
440 struct fschmd_data *data = fschmd_update_device(dev);
441
442 if (data->fan_status[index] & FSCHMD_FAN_NOT_PRESENT)
443 return sprintf(buf, "1\n");
444 else
445 return sprintf(buf, "0\n");
446 }
447
448
449 static ssize_t show_pwm_auto_point1_pwm(struct device *dev,
450 struct device_attribute *devattr, char *buf)
451 {
452 int index = to_sensor_dev_attr(devattr)->index;
453 int val = fschmd_update_device(dev)->fan_min[index];
454
455 /* 0 = allow turning off, 1-255 = 50-100% */
456 if (val)
457 val = val / 2 + 128;
458
459 return sprintf(buf, "%d\n", val);
460 }
461
462 static ssize_t store_pwm_auto_point1_pwm(struct device *dev,
463 struct device_attribute *devattr, const char *buf, size_t count)
464 {
465 int index = to_sensor_dev_attr(devattr)->index;
466 struct fschmd_data *data = dev_get_drvdata(dev);
467 unsigned long v = simple_strtoul(buf, NULL, 10);
468
469 /* register: 0 = allow turning off, 1-255 = 50-100% */
470 if (v) {
471 v = SENSORS_LIMIT(v, 128, 255);
472 v = (v - 128) * 2 + 1;
473 }
474
475 mutex_lock(&data->update_lock);
476
477 i2c_smbus_write_byte_data(to_i2c_client(dev),
478 FSCHMD_REG_FAN_MIN[data->kind][index], v);
479 data->fan_min[index] = v;
480
481 mutex_unlock(&data->update_lock);
482
483 return count;
484 }
485
486
487 /* The FSC hwmon family has the ability to force an attached alert led to flash
488 from software, we export this as an alert_led sysfs attr */
489 static ssize_t show_alert_led(struct device *dev,
490 struct device_attribute *devattr, char *buf)
491 {
492 struct fschmd_data *data = fschmd_update_device(dev);
493
494 if (data->global_control & FSCHMD_CONTROL_ALERT_LED)
495 return sprintf(buf, "1\n");
496 else
497 return sprintf(buf, "0\n");
498 }
499
500 static ssize_t store_alert_led(struct device *dev,
501 struct device_attribute *devattr, const char *buf, size_t count)
502 {
503 u8 reg;
504 struct fschmd_data *data = dev_get_drvdata(dev);
505 unsigned long v = simple_strtoul(buf, NULL, 10);
506
507 mutex_lock(&data->update_lock);
508
509 reg = i2c_smbus_read_byte_data(to_i2c_client(dev), FSCHMD_REG_CONTROL);
510
511 if (v)
512 reg |= FSCHMD_CONTROL_ALERT_LED;
513 else
514 reg &= ~FSCHMD_CONTROL_ALERT_LED;
515
516 i2c_smbus_write_byte_data(to_i2c_client(dev), FSCHMD_REG_CONTROL, reg);
517
518 data->global_control = reg;
519
520 mutex_unlock(&data->update_lock);
521
522 return count;
523 }
524
525 static struct sensor_device_attribute fschmd_attr[] = {
526 SENSOR_ATTR(in0_input, 0444, show_in_value, NULL, 0),
527 SENSOR_ATTR(in1_input, 0444, show_in_value, NULL, 1),
528 SENSOR_ATTR(in2_input, 0444, show_in_value, NULL, 2),
529 SENSOR_ATTR(alert_led, 0644, show_alert_led, store_alert_led, 0),
530 };
531
532 static struct sensor_device_attribute fschmd_temp_attr[] = {
533 SENSOR_ATTR(temp1_input, 0444, show_temp_value, NULL, 0),
534 SENSOR_ATTR(temp1_max, 0644, show_temp_max, store_temp_max, 0),
535 SENSOR_ATTR(temp1_fault, 0444, show_temp_fault, NULL, 0),
536 SENSOR_ATTR(temp1_alarm, 0444, show_temp_alarm, NULL, 0),
537 SENSOR_ATTR(temp2_input, 0444, show_temp_value, NULL, 1),
538 SENSOR_ATTR(temp2_max, 0644, show_temp_max, store_temp_max, 1),
539 SENSOR_ATTR(temp2_fault, 0444, show_temp_fault, NULL, 1),
540 SENSOR_ATTR(temp2_alarm, 0444, show_temp_alarm, NULL, 1),
541 SENSOR_ATTR(temp3_input, 0444, show_temp_value, NULL, 2),
542 SENSOR_ATTR(temp3_max, 0644, show_temp_max, store_temp_max, 2),
543 SENSOR_ATTR(temp3_fault, 0444, show_temp_fault, NULL, 2),
544 SENSOR_ATTR(temp3_alarm, 0444, show_temp_alarm, NULL, 2),
545 SENSOR_ATTR(temp4_input, 0444, show_temp_value, NULL, 3),
546 SENSOR_ATTR(temp4_max, 0644, show_temp_max, store_temp_max, 3),
547 SENSOR_ATTR(temp4_fault, 0444, show_temp_fault, NULL, 3),
548 SENSOR_ATTR(temp4_alarm, 0444, show_temp_alarm, NULL, 3),
549 SENSOR_ATTR(temp5_input, 0444, show_temp_value, NULL, 4),
550 SENSOR_ATTR(temp5_max, 0644, show_temp_max, store_temp_max, 4),
551 SENSOR_ATTR(temp5_fault, 0444, show_temp_fault, NULL, 4),
552 SENSOR_ATTR(temp5_alarm, 0444, show_temp_alarm, NULL, 4),
553 };
554
555 static struct sensor_device_attribute fschmd_fan_attr[] = {
556 SENSOR_ATTR(fan1_input, 0444, show_fan_value, NULL, 0),
557 SENSOR_ATTR(fan1_div, 0644, show_fan_div, store_fan_div, 0),
558 SENSOR_ATTR(fan1_alarm, 0444, show_fan_alarm, NULL, 0),
559 SENSOR_ATTR(fan1_fault, 0444, show_fan_fault, NULL, 0),
560 SENSOR_ATTR(pwm1_auto_point1_pwm, 0644, show_pwm_auto_point1_pwm,
561 store_pwm_auto_point1_pwm, 0),
562 SENSOR_ATTR(fan2_input, 0444, show_fan_value, NULL, 1),
563 SENSOR_ATTR(fan2_div, 0644, show_fan_div, store_fan_div, 1),
564 SENSOR_ATTR(fan2_alarm, 0444, show_fan_alarm, NULL, 1),
565 SENSOR_ATTR(fan2_fault, 0444, show_fan_fault, NULL, 1),
566 SENSOR_ATTR(pwm2_auto_point1_pwm, 0644, show_pwm_auto_point1_pwm,
567 store_pwm_auto_point1_pwm, 1),
568 SENSOR_ATTR(fan3_input, 0444, show_fan_value, NULL, 2),
569 SENSOR_ATTR(fan3_div, 0644, show_fan_div, store_fan_div, 2),
570 SENSOR_ATTR(fan3_alarm, 0444, show_fan_alarm, NULL, 2),
571 SENSOR_ATTR(fan3_fault, 0444, show_fan_fault, NULL, 2),
572 SENSOR_ATTR(pwm3_auto_point1_pwm, 0644, show_pwm_auto_point1_pwm,
573 store_pwm_auto_point1_pwm, 2),
574 SENSOR_ATTR(fan4_input, 0444, show_fan_value, NULL, 3),
575 SENSOR_ATTR(fan4_div, 0644, show_fan_div, store_fan_div, 3),
576 SENSOR_ATTR(fan4_alarm, 0444, show_fan_alarm, NULL, 3),
577 SENSOR_ATTR(fan4_fault, 0444, show_fan_fault, NULL, 3),
578 SENSOR_ATTR(pwm4_auto_point1_pwm, 0644, show_pwm_auto_point1_pwm,
579 store_pwm_auto_point1_pwm, 3),
580 SENSOR_ATTR(fan5_input, 0444, show_fan_value, NULL, 4),
581 SENSOR_ATTR(fan5_div, 0644, show_fan_div, store_fan_div, 4),
582 SENSOR_ATTR(fan5_alarm, 0444, show_fan_alarm, NULL, 4),
583 SENSOR_ATTR(fan5_fault, 0444, show_fan_fault, NULL, 4),
584 SENSOR_ATTR(pwm5_auto_point1_pwm, 0644, show_pwm_auto_point1_pwm,
585 store_pwm_auto_point1_pwm, 4),
586 SENSOR_ATTR(fan6_input, 0444, show_fan_value, NULL, 5),
587 SENSOR_ATTR(fan6_div, 0644, show_fan_div, store_fan_div, 5),
588 SENSOR_ATTR(fan6_alarm, 0444, show_fan_alarm, NULL, 5),
589 SENSOR_ATTR(fan6_fault, 0444, show_fan_fault, NULL, 5),
590 SENSOR_ATTR(pwm6_auto_point1_pwm, 0644, show_pwm_auto_point1_pwm,
591 store_pwm_auto_point1_pwm, 5),
592 };
593
594
595 /*
596 * Watchdog routines
597 */
598
599 static int watchdog_set_timeout(struct fschmd_data *data, int timeout)
600 {
601 int ret, resolution;
602 int kind = data->kind + 1; /* 0-x array index -> 1-x module param */
603
604 /* 2 second or 60 second resolution? */
605 if (timeout <= 510 || kind == fscpos || kind == fscscy)
606 resolution = 2;
607 else
608 resolution = 60;
609
610 if (timeout < resolution || timeout > (resolution * 255))
611 return -EINVAL;
612
613 mutex_lock(&data->watchdog_lock);
614 if (!data->client) {
615 ret = -ENODEV;
616 goto leave;
617 }
618
619 if (resolution == 2)
620 data->watchdog_control &= ~FSCHMD_WDOG_CONTROL_RESOLUTION;
621 else
622 data->watchdog_control |= FSCHMD_WDOG_CONTROL_RESOLUTION;
623
624 data->watchdog_preset = DIV_ROUND_UP(timeout, resolution);
625
626 /* Write new timeout value */
627 i2c_smbus_write_byte_data(data->client, FSCHMD_REG_WDOG_PRESET,
628 data->watchdog_preset);
629 /* Write new control register, do not trigger! */
630 i2c_smbus_write_byte_data(data->client, FSCHMD_REG_WDOG_CONTROL,
631 data->watchdog_control & ~FSCHMD_WDOG_CONTROL_TRIGGER);
632
633 ret = data->watchdog_preset * resolution;
634
635 leave:
636 mutex_unlock(&data->watchdog_lock);
637 return ret;
638 }
639
640 static int watchdog_get_timeout(struct fschmd_data *data)
641 {
642 int timeout;
643
644 mutex_lock(&data->watchdog_lock);
645 if (data->watchdog_control & FSCHMD_WDOG_CONTROL_RESOLUTION)
646 timeout = data->watchdog_preset * 60;
647 else
648 timeout = data->watchdog_preset * 2;
649 mutex_unlock(&data->watchdog_lock);
650
651 return timeout;
652 }
653
654 static int watchdog_trigger(struct fschmd_data *data)
655 {
656 int ret = 0;
657
658 mutex_lock(&data->watchdog_lock);
659 if (!data->client) {
660 ret = -ENODEV;
661 goto leave;
662 }
663
664 data->watchdog_control |= FSCHMD_WDOG_CONTROL_TRIGGER;
665 i2c_smbus_write_byte_data(data->client, FSCHMD_REG_WDOG_CONTROL,
666 data->watchdog_control);
667 leave:
668 mutex_unlock(&data->watchdog_lock);
669 return ret;
670 }
671
672 static int watchdog_stop(struct fschmd_data *data)
673 {
674 int ret = 0;
675
676 mutex_lock(&data->watchdog_lock);
677 if (!data->client) {
678 ret = -ENODEV;
679 goto leave;
680 }
681
682 data->watchdog_control &= ~FSCHMD_WDOG_CONTROL_STARTED;
683 /* Don't store the stop flag in our watchdog control register copy, as
684 its a write only bit (read always returns 0) */
685 i2c_smbus_write_byte_data(data->client, FSCHMD_REG_WDOG_CONTROL,
686 data->watchdog_control | FSCHMD_WDOG_CONTROL_STOP);
687 leave:
688 mutex_unlock(&data->watchdog_lock);
689 return ret;
690 }
691
692 static int watchdog_open(struct inode *inode, struct file *filp)
693 {
694 struct fschmd_data *pos, *data = NULL;
695
696 /* We get called from drivers/char/misc.c with misc_mtx hold, and we
697 call misc_register() from fschmd_probe() with watchdog_data_mutex
698 hold, as misc_register() takes the misc_mtx lock, this is a possible
699 deadlock, so we use mutex_trylock here. */
700 if (!mutex_trylock(&watchdog_data_mutex))
701 return -ERESTARTSYS;
702 list_for_each_entry(pos, &watchdog_data_list, list) {
703 if (pos->watchdog_miscdev.minor == iminor(inode)) {
704 data = pos;
705 break;
706 }
707 }
708 /* Note we can never not have found data, so we don't check for this */
709 kref_get(&data->kref);
710 mutex_unlock(&watchdog_data_mutex);
711
712 if (test_and_set_bit(0, &data->watchdog_is_open))
713 return -EBUSY;
714
715 /* Start the watchdog */
716 watchdog_trigger(data);
717 filp->private_data = data;
718
719 return nonseekable_open(inode, filp);
720 }
721
722 static int watchdog_release(struct inode *inode, struct file *filp)
723 {
724 struct fschmd_data *data = filp->private_data;
725
726 if (data->watchdog_expect_close) {
727 watchdog_stop(data);
728 data->watchdog_expect_close = 0;
729 } else {
730 watchdog_trigger(data);
731 dev_crit(&data->client->dev,
732 "unexpected close, not stopping watchdog!\n");
733 }
734
735 clear_bit(0, &data->watchdog_is_open);
736
737 mutex_lock(&watchdog_data_mutex);
738 kref_put(&data->kref, fschmd_release_resources);
739 mutex_unlock(&watchdog_data_mutex);
740
741 return 0;
742 }
743
744 static ssize_t watchdog_write(struct file *filp, const char __user *buf,
745 size_t count, loff_t *offset)
746 {
747 size_t ret;
748 struct fschmd_data *data = filp->private_data;
749
750 if (count) {
751 if (!nowayout) {
752 size_t i;
753
754 /* Clear it in case it was set with a previous write */
755 data->watchdog_expect_close = 0;
756
757 for (i = 0; i != count; i++) {
758 char c;
759 if (get_user(c, buf + i))
760 return -EFAULT;
761 if (c == 'V')
762 data->watchdog_expect_close = 1;
763 }
764 }
765 ret = watchdog_trigger(data);
766 if (ret < 0)
767 return ret;
768 }
769 return count;
770 }
771
772 static int watchdog_ioctl(struct inode *inode, struct file *filp,
773 unsigned int cmd, unsigned long arg)
774 {
775 static struct watchdog_info ident = {
776 .options = WDIOF_KEEPALIVEPING | WDIOF_SETTIMEOUT |
777 WDIOF_CARDRESET,
778 .identity = "FSC watchdog"
779 };
780 int i, ret = 0;
781 struct fschmd_data *data = filp->private_data;
782
783 switch (cmd) {
784 case WDIOC_GETSUPPORT:
785 ident.firmware_version = data->revision;
786 if (!nowayout)
787 ident.options |= WDIOF_MAGICCLOSE;
788 if (copy_to_user((void __user *)arg, &ident, sizeof(ident)))
789 ret = -EFAULT;
790 break;
791
792 case WDIOC_GETSTATUS:
793 ret = put_user(0, (int __user *)arg);
794 break;
795
796 case WDIOC_GETBOOTSTATUS:
797 if (data->watchdog_state & FSCHMD_WDOG_STATE_CARDRESET)
798 ret = put_user(WDIOF_CARDRESET, (int __user *)arg);
799 else
800 ret = put_user(0, (int __user *)arg);
801 break;
802
803 case WDIOC_KEEPALIVE:
804 ret = watchdog_trigger(data);
805 break;
806
807 case WDIOC_GETTIMEOUT:
808 i = watchdog_get_timeout(data);
809 ret = put_user(i, (int __user *)arg);
810 break;
811
812 case WDIOC_SETTIMEOUT:
813 if (get_user(i, (int __user *)arg)) {
814 ret = -EFAULT;
815 break;
816 }
817 ret = watchdog_set_timeout(data, i);
818 if (ret > 0)
819 ret = put_user(ret, (int __user *)arg);
820 break;
821
822 case WDIOC_SETOPTIONS:
823 if (get_user(i, (int __user *)arg)) {
824 ret = -EFAULT;
825 break;
826 }
827
828 if (i & WDIOS_DISABLECARD)
829 ret = watchdog_stop(data);
830 else if (i & WDIOS_ENABLECARD)
831 ret = watchdog_trigger(data);
832 else
833 ret = -EINVAL;
834
835 break;
836 default:
837 ret = -ENOTTY;
838 }
839
840 return ret;
841 }
842
843 static struct file_operations watchdog_fops = {
844 .owner = THIS_MODULE,
845 .llseek = no_llseek,
846 .open = watchdog_open,
847 .release = watchdog_release,
848 .write = watchdog_write,
849 .ioctl = watchdog_ioctl,
850 };
851
852
853 /*
854 * Detect, register, unregister and update device functions
855 */
856
857 /* DMI decode routine to read voltage scaling factors from special DMI tables,
858 which are available on FSC machines with an fscher or later chip. */
859 static void fschmd_dmi_decode(const struct dmi_header *header)
860 {
861 int i, mult[3] = { 0 }, offset[3] = { 0 }, vref = 0, found = 0;
862
863 /* dmi code ugliness, we get passed the address of the contents of
864 a complete DMI record, but in the form of a dmi_header pointer, in
865 reality this address holds header->length bytes of which the header
866 are the first 4 bytes */
867 u8 *dmi_data = (u8 *)header;
868
869 /* We are looking for OEM-specific type 185 */
870 if (header->type != 185)
871 return;
872
873 /* we are looking for what Siemens calls "subtype" 19, the subtype
874 is stored in byte 5 of the dmi block */
875 if (header->length < 5 || dmi_data[4] != 19)
876 return;
877
878 /* After the subtype comes 1 unknown byte and then blocks of 5 bytes,
879 consisting of what Siemens calls an "Entity" number, followed by
880 2 16-bit words in LSB first order */
881 for (i = 6; (i + 4) < header->length; i += 5) {
882 /* entity 1 - 3: voltage multiplier and offset */
883 if (dmi_data[i] >= 1 && dmi_data[i] <= 3) {
884 /* Our in sensors order and the DMI order differ */
885 const int shuffle[3] = { 1, 0, 2 };
886 int in = shuffle[dmi_data[i] - 1];
887
888 /* Check for twice the same entity */
889 if (found & (1 << in))
890 return;
891
892 mult[in] = dmi_data[i + 1] | (dmi_data[i + 2] << 8);
893 offset[in] = dmi_data[i + 3] | (dmi_data[i + 4] << 8);
894
895 found |= 1 << in;
896 }
897
898 /* entity 7: reference voltage */
899 if (dmi_data[i] == 7) {
900 /* Check for twice the same entity */
901 if (found & 0x08)
902 return;
903
904 vref = dmi_data[i + 1] | (dmi_data[i + 2] << 8);
905
906 found |= 0x08;
907 }
908 }
909
910 if (found == 0x0F) {
911 for (i = 0; i < 3; i++) {
912 dmi_mult[i] = mult[i] * 10;
913 dmi_offset[i] = offset[i] * 10;
914 }
915 dmi_vref = vref;
916 }
917 }
918
919 static int fschmd_detect(struct i2c_client *client, int kind,
920 struct i2c_board_info *info)
921 {
922 struct i2c_adapter *adapter = client->adapter;
923 const char * const client_names[5] = { "fscpos", "fscher", "fscscy",
924 "fschrc", "fschmd" };
925
926 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
927 return -ENODEV;
928
929 /* Detect & Identify the chip */
930 if (kind <= 0) {
931 char id[4];
932
933 id[0] = i2c_smbus_read_byte_data(client,
934 FSCHMD_REG_IDENT_0);
935 id[1] = i2c_smbus_read_byte_data(client,
936 FSCHMD_REG_IDENT_1);
937 id[2] = i2c_smbus_read_byte_data(client,
938 FSCHMD_REG_IDENT_2);
939 id[3] = '\0';
940
941 if (!strcmp(id, "PEG"))
942 kind = fscpos;
943 else if (!strcmp(id, "HER"))
944 kind = fscher;
945 else if (!strcmp(id, "SCY"))
946 kind = fscscy;
947 else if (!strcmp(id, "HRC"))
948 kind = fschrc;
949 else if (!strcmp(id, "HMD"))
950 kind = fschmd;
951 else
952 return -ENODEV;
953 }
954
955 strlcpy(info->type, client_names[kind - 1], I2C_NAME_SIZE);
956
957 return 0;
958 }
959
960 static int fschmd_probe(struct i2c_client *client,
961 const struct i2c_device_id *id)
962 {
963 struct fschmd_data *data;
964 const char * const names[5] = { "Poseidon", "Hermes", "Scylla",
965 "Heracles", "Heimdall" };
966 const int watchdog_minors[] = { WATCHDOG_MINOR, 212, 213, 214, 215 };
967 int i, err;
968 enum chips kind = id->driver_data;
969
970 data = kzalloc(sizeof(struct fschmd_data), GFP_KERNEL);
971 if (!data)
972 return -ENOMEM;
973
974 i2c_set_clientdata(client, data);
975 mutex_init(&data->update_lock);
976 mutex_init(&data->watchdog_lock);
977 INIT_LIST_HEAD(&data->list);
978 kref_init(&data->kref);
979 /* Store client pointer in our data struct for watchdog usage
980 (where the client is found through a data ptr instead of the
981 otherway around) */
982 data->client = client;
983
984 if (kind == fscpos) {
985 /* The Poseidon has hardwired temp limits, fill these
986 in for the alarm resetting code */
987 data->temp_max[0] = 70 + 128;
988 data->temp_max[1] = 50 + 128;
989 data->temp_max[2] = 50 + 128;
990 }
991
992 /* Read the special DMI table for fscher and newer chips */
993 if ((kind == fscher || kind >= fschrc) && dmi_vref == -1) {
994 dmi_walk(fschmd_dmi_decode);
995 if (dmi_vref == -1) {
996 dev_warn(&client->dev,
997 "Couldn't get voltage scaling factors from "
998 "BIOS DMI table, using builtin defaults\n");
999 dmi_vref = 33;
1000 }
1001 }
1002
1003 /* Read in some never changing registers */
1004 data->revision = i2c_smbus_read_byte_data(client, FSCHMD_REG_REVISION);
1005 data->global_control = i2c_smbus_read_byte_data(client,
1006 FSCHMD_REG_CONTROL);
1007 data->watchdog_control = i2c_smbus_read_byte_data(client,
1008 FSCHMD_REG_WDOG_CONTROL);
1009 data->watchdog_state = i2c_smbus_read_byte_data(client,
1010 FSCHMD_REG_WDOG_STATE);
1011 data->watchdog_preset = i2c_smbus_read_byte_data(client,
1012 FSCHMD_REG_WDOG_PRESET);
1013
1014 /* i2c kind goes from 1-5, we want from 0-4 to address arrays */
1015 data->kind = kind - 1;
1016
1017 for (i = 0; i < ARRAY_SIZE(fschmd_attr); i++) {
1018 err = device_create_file(&client->dev,
1019 &fschmd_attr[i].dev_attr);
1020 if (err)
1021 goto exit_detach;
1022 }
1023
1024 for (i = 0; i < (FSCHMD_NO_TEMP_SENSORS[data->kind] * 4); i++) {
1025 /* Poseidon doesn't have TEMP_LIMIT registers */
1026 if (kind == fscpos && fschmd_temp_attr[i].dev_attr.show ==
1027 show_temp_max)
1028 continue;
1029
1030 err = device_create_file(&client->dev,
1031 &fschmd_temp_attr[i].dev_attr);
1032 if (err)
1033 goto exit_detach;
1034 }
1035
1036 for (i = 0; i < (FSCHMD_NO_FAN_SENSORS[data->kind] * 5); i++) {
1037 /* Poseidon doesn't have a FAN_MIN register for its 3rd fan */
1038 if (kind == fscpos &&
1039 !strcmp(fschmd_fan_attr[i].dev_attr.attr.name,
1040 "pwm3_auto_point1_pwm"))
1041 continue;
1042
1043 err = device_create_file(&client->dev,
1044 &fschmd_fan_attr[i].dev_attr);
1045 if (err)
1046 goto exit_detach;
1047 }
1048
1049 data->hwmon_dev = hwmon_device_register(&client->dev);
1050 if (IS_ERR(data->hwmon_dev)) {
1051 err = PTR_ERR(data->hwmon_dev);
1052 data->hwmon_dev = NULL;
1053 goto exit_detach;
1054 }
1055
1056 /* We take the data_mutex lock early so that watchdog_open() cannot
1057 run when misc_register() has completed, but we've not yet added
1058 our data to the watchdog_data_list (and set the default timeout) */
1059 mutex_lock(&watchdog_data_mutex);
1060 for (i = 0; i < ARRAY_SIZE(watchdog_minors); i++) {
1061 /* Register our watchdog part */
1062 snprintf(data->watchdog_name, sizeof(data->watchdog_name),
1063 "watchdog%c", (i == 0) ? '\0' : ('0' + i));
1064 data->watchdog_miscdev.name = data->watchdog_name;
1065 data->watchdog_miscdev.fops = &watchdog_fops;
1066 data->watchdog_miscdev.minor = watchdog_minors[i];
1067 err = misc_register(&data->watchdog_miscdev);
1068 if (err == -EBUSY)
1069 continue;
1070 if (err) {
1071 data->watchdog_miscdev.minor = 0;
1072 dev_err(&client->dev,
1073 "Registering watchdog chardev: %d\n", err);
1074 break;
1075 }
1076
1077 list_add(&data->list, &watchdog_data_list);
1078 watchdog_set_timeout(data, 60);
1079 dev_info(&client->dev,
1080 "Registered watchdog chardev major 10, minor: %d\n",
1081 watchdog_minors[i]);
1082 break;
1083 }
1084 if (i == ARRAY_SIZE(watchdog_minors)) {
1085 data->watchdog_miscdev.minor = 0;
1086 dev_warn(&client->dev, "Couldn't register watchdog chardev "
1087 "(due to no free minor)\n");
1088 }
1089 mutex_unlock(&watchdog_data_mutex);
1090
1091 dev_info(&client->dev, "Detected FSC %s chip, revision: %d\n",
1092 names[data->kind], (int) data->revision);
1093
1094 return 0;
1095
1096 exit_detach:
1097 fschmd_remove(client); /* will also free data for us */
1098 return err;
1099 }
1100
1101 static int fschmd_remove(struct i2c_client *client)
1102 {
1103 struct fschmd_data *data = i2c_get_clientdata(client);
1104 int i;
1105
1106 /* Unregister the watchdog (if registered) */
1107 if (data->watchdog_miscdev.minor) {
1108 misc_deregister(&data->watchdog_miscdev);
1109 if (data->watchdog_is_open) {
1110 dev_warn(&client->dev,
1111 "i2c client detached with watchdog open! "
1112 "Stopping watchdog.\n");
1113 watchdog_stop(data);
1114 }
1115 mutex_lock(&watchdog_data_mutex);
1116 list_del(&data->list);
1117 mutex_unlock(&watchdog_data_mutex);
1118 /* Tell the watchdog code the client is gone */
1119 mutex_lock(&data->watchdog_lock);
1120 data->client = NULL;
1121 mutex_unlock(&data->watchdog_lock);
1122 }
1123
1124 /* Check if registered in case we're called from fschmd_detect
1125 to cleanup after an error */
1126 if (data->hwmon_dev)
1127 hwmon_device_unregister(data->hwmon_dev);
1128
1129 for (i = 0; i < ARRAY_SIZE(fschmd_attr); i++)
1130 device_remove_file(&client->dev, &fschmd_attr[i].dev_attr);
1131 for (i = 0; i < (FSCHMD_NO_TEMP_SENSORS[data->kind] * 4); i++)
1132 device_remove_file(&client->dev,
1133 &fschmd_temp_attr[i].dev_attr);
1134 for (i = 0; i < (FSCHMD_NO_FAN_SENSORS[data->kind] * 5); i++)
1135 device_remove_file(&client->dev,
1136 &fschmd_fan_attr[i].dev_attr);
1137
1138 mutex_lock(&watchdog_data_mutex);
1139 kref_put(&data->kref, fschmd_release_resources);
1140 mutex_unlock(&watchdog_data_mutex);
1141
1142 return 0;
1143 }
1144
1145 static struct fschmd_data *fschmd_update_device(struct device *dev)
1146 {
1147 struct i2c_client *client = to_i2c_client(dev);
1148 struct fschmd_data *data = i2c_get_clientdata(client);
1149 int i;
1150
1151 mutex_lock(&data->update_lock);
1152
1153 if (time_after(jiffies, data->last_updated + 2 * HZ) || !data->valid) {
1154
1155 for (i = 0; i < FSCHMD_NO_TEMP_SENSORS[data->kind]; i++) {
1156 data->temp_act[i] = i2c_smbus_read_byte_data(client,
1157 FSCHMD_REG_TEMP_ACT[data->kind][i]);
1158 data->temp_status[i] = i2c_smbus_read_byte_data(client,
1159 FSCHMD_REG_TEMP_STATE[data->kind][i]);
1160
1161 /* The fscpos doesn't have TEMP_LIMIT registers */
1162 if (FSCHMD_REG_TEMP_LIMIT[data->kind][i])
1163 data->temp_max[i] = i2c_smbus_read_byte_data(
1164 client,
1165 FSCHMD_REG_TEMP_LIMIT[data->kind][i]);
1166
1167 /* reset alarm if the alarm condition is gone,
1168 the chip doesn't do this itself */
1169 if ((data->temp_status[i] & FSCHMD_TEMP_ALARM_MASK) ==
1170 FSCHMD_TEMP_ALARM_MASK &&
1171 data->temp_act[i] < data->temp_max[i])
1172 i2c_smbus_write_byte_data(client,
1173 FSCHMD_REG_TEMP_STATE[data->kind][i],
1174 FSCHMD_TEMP_ALERT);
1175 }
1176
1177 for (i = 0; i < FSCHMD_NO_FAN_SENSORS[data->kind]; i++) {
1178 data->fan_act[i] = i2c_smbus_read_byte_data(client,
1179 FSCHMD_REG_FAN_ACT[data->kind][i]);
1180 data->fan_status[i] = i2c_smbus_read_byte_data(client,
1181 FSCHMD_REG_FAN_STATE[data->kind][i]);
1182 data->fan_ripple[i] = i2c_smbus_read_byte_data(client,
1183 FSCHMD_REG_FAN_RIPPLE[data->kind][i]);
1184
1185 /* The fscpos third fan doesn't have a fan_min */
1186 if (FSCHMD_REG_FAN_MIN[data->kind][i])
1187 data->fan_min[i] = i2c_smbus_read_byte_data(
1188 client,
1189 FSCHMD_REG_FAN_MIN[data->kind][i]);
1190
1191 /* reset fan status if speed is back to > 0 */
1192 if ((data->fan_status[i] & FSCHMD_FAN_ALARM) &&
1193 data->fan_act[i])
1194 i2c_smbus_write_byte_data(client,
1195 FSCHMD_REG_FAN_STATE[data->kind][i],
1196 FSCHMD_FAN_ALARM);
1197 }
1198
1199 for (i = 0; i < 3; i++)
1200 data->volt[i] = i2c_smbus_read_byte_data(client,
1201 FSCHMD_REG_VOLT[i]);
1202
1203 data->last_updated = jiffies;
1204 data->valid = 1;
1205 }
1206
1207 mutex_unlock(&data->update_lock);
1208
1209 return data;
1210 }
1211
1212 static int __init fschmd_init(void)
1213 {
1214 return i2c_add_driver(&fschmd_driver);
1215 }
1216
1217 static void __exit fschmd_exit(void)
1218 {
1219 i2c_del_driver(&fschmd_driver);
1220 }
1221
1222 MODULE_AUTHOR("Hans de Goede <hdegoede@redhat.com>");
1223 MODULE_DESCRIPTION("FSC Poseidon, Hermes, Scylla, Heracles and "
1224 "Heimdall driver");
1225 MODULE_LICENSE("GPL");
1226
1227 module_init(fschmd_init);
1228 module_exit(fschmd_exit);
Support for the Chinese Samsung S3C2440 based development boards