4 * Copyright (C) 2007 - 2009 Hans de Goede <hdegoede@redhat.com>
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.
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.
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.
22 * Merged Fujitsu Siemens hwmon driver, supporting the Poseidon, Hermes,
23 * Scylla, Heracles, Heimdall, Hades and Syleus chips
25 * Based on the original 2.4 fscscy, 2.6 fscpos, 2.6 fscher and 2.6
26 * (candidate) fschmd drivers:
27 * Copyright (C) 2006 Thilo Cestonaro
28 * <thilo.cestonaro.external@fujitsu-siemens.com>
29 * Copyright (C) 2004, 2005 Stefan Ott <stefan@desire.ch>
30 * Copyright (C) 2003, 2004 Reinhard Nissl <rnissl@gmx.de>
31 * Copyright (c) 2001 Martin Knoblauch <mkn@teraport.de, knobi@knobisoft.de>
32 * Copyright (C) 2000 Hermann Jung <hej@odn.de>
35 #include <linux/module.h>
36 #include <linux/init.h>
37 #include <linux/slab.h>
38 #include <linux/jiffies.h>
39 #include <linux/i2c.h>
40 #include <linux/hwmon.h>
41 #include <linux/hwmon-sysfs.h>
42 #include <linux/err.h>
43 #include <linux/mutex.h>
44 #include <linux/sysfs.h>
45 #include <linux/dmi.h>
47 #include <linux/watchdog.h>
48 #include <linux/miscdevice.h>
49 #include <linux/uaccess.h>
50 #include <linux/kref.h>
52 /* Addresses to scan */
53 static const unsigned short normal_i2c[] = { 0x73, I2C_CLIENT_END };
55 /* Insmod parameters */
56 static bool nowayout = WATCHDOG_NOWAYOUT;
57 module_param(nowayout, bool, 0);
58 MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started (default="
59 __MODULE_STRING(WATCHDOG_NOWAYOUT) ")");
61 enum chips { fscpos, fscher, fscscy, fschrc, fschmd, fschds, fscsyl };
64 * The FSCHMD registers and other defines
67 /* chip identification */
68 #define FSCHMD_REG_IDENT_0 0x00
69 #define FSCHMD_REG_IDENT_1 0x01
70 #define FSCHMD_REG_IDENT_2 0x02
71 #define FSCHMD_REG_REVISION 0x03
73 /* global control and status */
74 #define FSCHMD_REG_EVENT_STATE 0x04
75 #define FSCHMD_REG_CONTROL 0x05
77 #define FSCHMD_CONTROL_ALERT_LED 0x01
80 static const u8 FSCHMD_REG_WDOG_CONTROL[7] = {
81 0x21, 0x21, 0x21, 0x21, 0x21, 0x28, 0x28 };
82 static const u8 FSCHMD_REG_WDOG_STATE[7] = {
83 0x23, 0x23, 0x23, 0x23, 0x23, 0x29, 0x29 };
84 static const u8 FSCHMD_REG_WDOG_PRESET[7] = {
85 0x28, 0x28, 0x28, 0x28, 0x28, 0x2a, 0x2a };
87 #define FSCHMD_WDOG_CONTROL_TRIGGER 0x10
88 #define FSCHMD_WDOG_CONTROL_STARTED 0x10 /* the same as trigger */
89 #define FSCHMD_WDOG_CONTROL_STOP 0x20
90 #define FSCHMD_WDOG_CONTROL_RESOLUTION 0x40
92 #define FSCHMD_WDOG_STATE_CARDRESET 0x02
94 /* voltages, weird order is to keep the same order as the old drivers */
95 static const u8 FSCHMD_REG_VOLT[7][6] = {
96 { 0x45, 0x42, 0x48 }, /* pos */
97 { 0x45, 0x42, 0x48 }, /* her */
98 { 0x45, 0x42, 0x48 }, /* scy */
99 { 0x45, 0x42, 0x48 }, /* hrc */
100 { 0x45, 0x42, 0x48 }, /* hmd */
101 { 0x21, 0x20, 0x22 }, /* hds */
102 { 0x21, 0x20, 0x22, 0x23, 0x24, 0x25 }, /* syl */
105 static const int FSCHMD_NO_VOLT_SENSORS[7] = { 3, 3, 3, 3, 3, 3, 6 };
108 * minimum pwm at which the fan is driven (pwm can by increased depending on
109 * the temp. Notice that for the scy some fans share there minimum speed.
110 * Also notice that with the scy the sensor order is different than with the
111 * other chips, this order was in the 2.4 driver and kept for consistency.
113 static const u8 FSCHMD_REG_FAN_MIN[7][7] = {
114 { 0x55, 0x65 }, /* pos */
115 { 0x55, 0x65, 0xb5 }, /* her */
116 { 0x65, 0x65, 0x55, 0xa5, 0x55, 0xa5 }, /* scy */
117 { 0x55, 0x65, 0xa5, 0xb5 }, /* hrc */
118 { 0x55, 0x65, 0xa5, 0xb5, 0xc5 }, /* hmd */
119 { 0x55, 0x65, 0xa5, 0xb5, 0xc5 }, /* hds */
120 { 0x54, 0x64, 0x74, 0x84, 0x94, 0xa4, 0xb4 }, /* syl */
123 /* actual fan speed */
124 static const u8 FSCHMD_REG_FAN_ACT[7][7] = {
125 { 0x0e, 0x6b, 0xab }, /* pos */
126 { 0x0e, 0x6b, 0xbb }, /* her */
127 { 0x6b, 0x6c, 0x0e, 0xab, 0x5c, 0xbb }, /* scy */
128 { 0x0e, 0x6b, 0xab, 0xbb }, /* hrc */
129 { 0x5b, 0x6b, 0xab, 0xbb, 0xcb }, /* hmd */
130 { 0x5b, 0x6b, 0xab, 0xbb, 0xcb }, /* hds */
131 { 0x57, 0x67, 0x77, 0x87, 0x97, 0xa7, 0xb7 }, /* syl */
134 /* fan status registers */
135 static const u8 FSCHMD_REG_FAN_STATE[7][7] = {
136 { 0x0d, 0x62, 0xa2 }, /* pos */
137 { 0x0d, 0x62, 0xb2 }, /* her */
138 { 0x62, 0x61, 0x0d, 0xa2, 0x52, 0xb2 }, /* scy */
139 { 0x0d, 0x62, 0xa2, 0xb2 }, /* hrc */
140 { 0x52, 0x62, 0xa2, 0xb2, 0xc2 }, /* hmd */
141 { 0x52, 0x62, 0xa2, 0xb2, 0xc2 }, /* hds */
142 { 0x50, 0x60, 0x70, 0x80, 0x90, 0xa0, 0xb0 }, /* syl */
145 /* fan ripple / divider registers */
146 static const u8 FSCHMD_REG_FAN_RIPPLE[7][7] = {
147 { 0x0f, 0x6f, 0xaf }, /* pos */
148 { 0x0f, 0x6f, 0xbf }, /* her */
149 { 0x6f, 0x6f, 0x0f, 0xaf, 0x0f, 0xbf }, /* scy */
150 { 0x0f, 0x6f, 0xaf, 0xbf }, /* hrc */
151 { 0x5f, 0x6f, 0xaf, 0xbf, 0xcf }, /* hmd */
152 { 0x5f, 0x6f, 0xaf, 0xbf, 0xcf }, /* hds */
153 { 0x56, 0x66, 0x76, 0x86, 0x96, 0xa6, 0xb6 }, /* syl */
156 static const int FSCHMD_NO_FAN_SENSORS[7] = { 3, 3, 6, 4, 5, 5, 7 };
158 /* Fan status register bitmasks */
159 #define FSCHMD_FAN_ALARM 0x04 /* called fault by FSC! */
160 #define FSCHMD_FAN_NOT_PRESENT 0x08
161 #define FSCHMD_FAN_DISABLED 0x80
164 /* actual temperature registers */
165 static const u8 FSCHMD_REG_TEMP_ACT[7][11] = {
166 { 0x64, 0x32, 0x35 }, /* pos */
167 { 0x64, 0x32, 0x35 }, /* her */
168 { 0x64, 0xD0, 0x32, 0x35 }, /* scy */
169 { 0x64, 0x32, 0x35 }, /* hrc */
170 { 0x70, 0x80, 0x90, 0xd0, 0xe0 }, /* hmd */
171 { 0x70, 0x80, 0x90, 0xd0, 0xe0 }, /* hds */
172 { 0x58, 0x68, 0x78, 0x88, 0x98, 0xa8, /* syl */
173 0xb8, 0xc8, 0xd8, 0xe8, 0xf8 },
176 /* temperature state registers */
177 static const u8 FSCHMD_REG_TEMP_STATE[7][11] = {
178 { 0x71, 0x81, 0x91 }, /* pos */
179 { 0x71, 0x81, 0x91 }, /* her */
180 { 0x71, 0xd1, 0x81, 0x91 }, /* scy */
181 { 0x71, 0x81, 0x91 }, /* hrc */
182 { 0x71, 0x81, 0x91, 0xd1, 0xe1 }, /* hmd */
183 { 0x71, 0x81, 0x91, 0xd1, 0xe1 }, /* hds */
184 { 0x59, 0x69, 0x79, 0x89, 0x99, 0xa9, /* syl */
185 0xb9, 0xc9, 0xd9, 0xe9, 0xf9 },
189 * temperature high limit registers, FSC does not document these. Proven to be
190 * there with field testing on the fscher and fschrc, already supported / used
191 * in the fscscy 2.4 driver. FSC has confirmed that the fschmd has registers
192 * at these addresses, but doesn't want to confirm they are the same as with
195 static const u8 FSCHMD_REG_TEMP_LIMIT[7][11] = {
196 { 0, 0, 0 }, /* pos */
197 { 0x76, 0x86, 0x96 }, /* her */
198 { 0x76, 0xd6, 0x86, 0x96 }, /* scy */
199 { 0x76, 0x86, 0x96 }, /* hrc */
200 { 0x76, 0x86, 0x96, 0xd6, 0xe6 }, /* hmd */
201 { 0x76, 0x86, 0x96, 0xd6, 0xe6 }, /* hds */
202 { 0x5a, 0x6a, 0x7a, 0x8a, 0x9a, 0xaa, /* syl */
203 0xba, 0xca, 0xda, 0xea, 0xfa },
207 * These were found through experimenting with an fscher, currently they are
208 * not used, but we keep them around for future reference.
209 * On the fscsyl AUTOP1 lives at 0x#c (so 0x5c for fan1, 0x6c for fan2, etc),
210 * AUTOP2 lives at 0x#e, and 0x#1 is a bitmask defining which temps influence
212 * static const u8 FSCHER_REG_TEMP_AUTOP1[] = { 0x73, 0x83, 0x93 };
213 * static const u8 FSCHER_REG_TEMP_AUTOP2[] = { 0x75, 0x85, 0x95 };
216 static const int FSCHMD_NO_TEMP_SENSORS[7] = { 3, 3, 4, 3, 5, 5, 11 };
218 /* temp status register bitmasks */
219 #define FSCHMD_TEMP_WORKING 0x01
220 #define FSCHMD_TEMP_ALERT 0x02
221 #define FSCHMD_TEMP_DISABLED 0x80
222 /* there only really is an alarm if the sensor is working and alert == 1 */
223 #define FSCHMD_TEMP_ALARM_MASK \
224 (FSCHMD_TEMP_WORKING | FSCHMD_TEMP_ALERT)
227 * Functions declarations
230 static int fschmd_probe(struct i2c_client *client,
231 const struct i2c_device_id *id);
232 static int fschmd_detect(struct i2c_client *client,
233 struct i2c_board_info *info);
234 static int fschmd_remove(struct i2c_client *client);
235 static struct fschmd_data *fschmd_update_device(struct device *dev);
238 * Driver data (common to all clients)
241 static const struct i2c_device_id fschmd_id[] = {
242 { "fscpos", fscpos },
243 { "fscher", fscher },
244 { "fscscy", fscscy },
245 { "fschrc", fschrc },
246 { "fschmd", fschmd },
247 { "fschds", fschds },
248 { "fscsyl", fscsyl },
251 MODULE_DEVICE_TABLE(i2c, fschmd_id);
253 static struct i2c_driver fschmd_driver = {
254 .class = I2C_CLASS_HWMON,
258 .probe = fschmd_probe,
259 .remove = fschmd_remove,
260 .id_table = fschmd_id,
261 .detect = fschmd_detect,
262 .address_list = normal_i2c,
266 * Client data (each client gets its own)
270 struct i2c_client *client;
271 struct device *hwmon_dev;
272 struct mutex update_lock;
273 struct mutex watchdog_lock;
274 struct list_head list; /* member of the watchdog_data_list */
276 struct miscdevice watchdog_miscdev;
278 unsigned long watchdog_is_open;
279 char watchdog_expect_close;
280 char watchdog_name[10]; /* must be unique to avoid sysfs conflict */
281 char valid; /* zero until following fields are valid */
282 unsigned long last_updated; /* in jiffies */
284 /* register values */
285 u8 revision; /* chip revision */
286 u8 global_control; /* global control register */
287 u8 watchdog_control; /* watchdog control register */
288 u8 watchdog_state; /* watchdog status register */
289 u8 watchdog_preset; /* watchdog counter preset on trigger val */
290 u8 volt[6]; /* voltage */
291 u8 temp_act[11]; /* temperature */
292 u8 temp_status[11]; /* status of sensor */
293 u8 temp_max[11]; /* high temp limit, notice: undocumented! */
294 u8 fan_act[7]; /* fans revolutions per second */
295 u8 fan_status[7]; /* fan status */
296 u8 fan_min[7]; /* fan min value for rps */
297 u8 fan_ripple[7]; /* divider for rps */
301 * Global variables to hold information read from special DMI tables, which are
302 * available on FSC machines with an fscher or later chip. There is no need to
303 * protect these with a lock as they are only modified from our attach function
304 * which always gets called with the i2c-core lock held and never accessed
305 * before the attach function is done with them.
307 static int dmi_mult[6] = { 490, 200, 100, 100, 200, 100 };
308 static int dmi_offset[6] = { 0, 0, 0, 0, 0, 0 };
309 static int dmi_vref = -1;
312 * Somewhat ugly :( global data pointer list with all fschmd devices, so that
313 * we can find our device data as when using misc_register there is no other
314 * method to get to ones device data from the open fop.
316 static LIST_HEAD(watchdog_data_list);
317 /* Note this lock not only protect list access, but also data.kref access */
318 static DEFINE_MUTEX(watchdog_data_mutex);
321 * Release our data struct when we're detached from the i2c client *and* all
322 * references to our watchdog device are released
324 static void fschmd_release_resources(struct kref *ref)
326 struct fschmd_data *data = container_of(ref, struct fschmd_data, kref);
331 * Sysfs attr show / store functions
334 static ssize_t show_in_value(struct device *dev,
335 struct device_attribute *devattr, char *buf)
337 const int max_reading[3] = { 14200, 6600, 3300 };
338 int index = to_sensor_dev_attr(devattr)->index;
339 struct fschmd_data *data = fschmd_update_device(dev);
341 if (data->kind == fscher || data->kind >= fschrc)
342 return sprintf(buf, "%d\n", (data->volt[index] * dmi_vref *
343 dmi_mult[index]) / 255 + dmi_offset[index]);
345 return sprintf(buf, "%d\n", (data->volt[index] *
346 max_reading[index] + 128) / 255);
350 #define TEMP_FROM_REG(val) (((val) - 128) * 1000)
352 static ssize_t show_temp_value(struct device *dev,
353 struct device_attribute *devattr, char *buf)
355 int index = to_sensor_dev_attr(devattr)->index;
356 struct fschmd_data *data = fschmd_update_device(dev);
358 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_act[index]));
361 static ssize_t show_temp_max(struct device *dev,
362 struct device_attribute *devattr, char *buf)
364 int index = to_sensor_dev_attr(devattr)->index;
365 struct fschmd_data *data = fschmd_update_device(dev);
367 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_max[index]));
370 static ssize_t store_temp_max(struct device *dev, struct device_attribute
371 *devattr, const char *buf, size_t count)
373 int index = to_sensor_dev_attr(devattr)->index;
374 struct fschmd_data *data = dev_get_drvdata(dev);
378 err = kstrtol(buf, 10, &v);
382 v = SENSORS_LIMIT(v / 1000, -128, 127) + 128;
384 mutex_lock(&data->update_lock);
385 i2c_smbus_write_byte_data(to_i2c_client(dev),
386 FSCHMD_REG_TEMP_LIMIT[data->kind][index], v);
387 data->temp_max[index] = v;
388 mutex_unlock(&data->update_lock);
393 static ssize_t show_temp_fault(struct device *dev,
394 struct device_attribute *devattr, char *buf)
396 int index = to_sensor_dev_attr(devattr)->index;
397 struct fschmd_data *data = fschmd_update_device(dev);
399 /* bit 0 set means sensor working ok, so no fault! */
400 if (data->temp_status[index] & FSCHMD_TEMP_WORKING)
401 return sprintf(buf, "0\n");
403 return sprintf(buf, "1\n");
406 static ssize_t show_temp_alarm(struct device *dev,
407 struct device_attribute *devattr, char *buf)
409 int index = to_sensor_dev_attr(devattr)->index;
410 struct fschmd_data *data = fschmd_update_device(dev);
412 if ((data->temp_status[index] & FSCHMD_TEMP_ALARM_MASK) ==
413 FSCHMD_TEMP_ALARM_MASK)
414 return sprintf(buf, "1\n");
416 return sprintf(buf, "0\n");
420 #define RPM_FROM_REG(val) ((val) * 60)
422 static ssize_t show_fan_value(struct device *dev,
423 struct device_attribute *devattr, char *buf)
425 int index = to_sensor_dev_attr(devattr)->index;
426 struct fschmd_data *data = fschmd_update_device(dev);
428 return sprintf(buf, "%u\n", RPM_FROM_REG(data->fan_act[index]));
431 static ssize_t show_fan_div(struct device *dev,
432 struct device_attribute *devattr, char *buf)
434 int index = to_sensor_dev_attr(devattr)->index;
435 struct fschmd_data *data = fschmd_update_device(dev);
437 /* bits 2..7 reserved => mask with 3 */
438 return sprintf(buf, "%d\n", 1 << (data->fan_ripple[index] & 3));
441 static ssize_t store_fan_div(struct device *dev, struct device_attribute
442 *devattr, const char *buf, size_t count)
445 int index = to_sensor_dev_attr(devattr)->index;
446 struct fschmd_data *data = dev_get_drvdata(dev);
447 /* supported values: 2, 4, 8 */
451 err = kstrtoul(buf, 10, &v);
466 dev_err(dev, "fan_div value %lu not supported. "
467 "Choose one of 2, 4 or 8!\n", v);
471 mutex_lock(&data->update_lock);
473 reg = i2c_smbus_read_byte_data(to_i2c_client(dev),
474 FSCHMD_REG_FAN_RIPPLE[data->kind][index]);
476 /* bits 2..7 reserved => mask with 0x03 */
480 i2c_smbus_write_byte_data(to_i2c_client(dev),
481 FSCHMD_REG_FAN_RIPPLE[data->kind][index], reg);
483 data->fan_ripple[index] = reg;
485 mutex_unlock(&data->update_lock);
490 static ssize_t show_fan_alarm(struct device *dev,
491 struct device_attribute *devattr, char *buf)
493 int index = to_sensor_dev_attr(devattr)->index;
494 struct fschmd_data *data = fschmd_update_device(dev);
496 if (data->fan_status[index] & FSCHMD_FAN_ALARM)
497 return sprintf(buf, "1\n");
499 return sprintf(buf, "0\n");
502 static ssize_t show_fan_fault(struct device *dev,
503 struct device_attribute *devattr, char *buf)
505 int index = to_sensor_dev_attr(devattr)->index;
506 struct fschmd_data *data = fschmd_update_device(dev);
508 if (data->fan_status[index] & FSCHMD_FAN_NOT_PRESENT)
509 return sprintf(buf, "1\n");
511 return sprintf(buf, "0\n");
515 static ssize_t show_pwm_auto_point1_pwm(struct device *dev,
516 struct device_attribute *devattr, char *buf)
518 int index = to_sensor_dev_attr(devattr)->index;
519 struct fschmd_data *data = fschmd_update_device(dev);
520 int val = data->fan_min[index];
522 /* 0 = allow turning off (except on the syl), 1-255 = 50-100% */
523 if (val || data->kind == fscsyl)
526 return sprintf(buf, "%d\n", val);
529 static ssize_t store_pwm_auto_point1_pwm(struct device *dev,
530 struct device_attribute *devattr, const char *buf, size_t count)
532 int index = to_sensor_dev_attr(devattr)->index;
533 struct fschmd_data *data = dev_get_drvdata(dev);
537 err = kstrtoul(buf, 10, &v);
541 /* reg: 0 = allow turning off (except on the syl), 1-255 = 50-100% */
542 if (v || data->kind == fscsyl) {
543 v = SENSORS_LIMIT(v, 128, 255);
544 v = (v - 128) * 2 + 1;
547 mutex_lock(&data->update_lock);
549 i2c_smbus_write_byte_data(to_i2c_client(dev),
550 FSCHMD_REG_FAN_MIN[data->kind][index], v);
551 data->fan_min[index] = v;
553 mutex_unlock(&data->update_lock);
560 * The FSC hwmon family has the ability to force an attached alert led to flash
561 * from software, we export this as an alert_led sysfs attr
563 static ssize_t show_alert_led(struct device *dev,
564 struct device_attribute *devattr, char *buf)
566 struct fschmd_data *data = fschmd_update_device(dev);
568 if (data->global_control & FSCHMD_CONTROL_ALERT_LED)
569 return sprintf(buf, "1\n");
571 return sprintf(buf, "0\n");
574 static ssize_t store_alert_led(struct device *dev,
575 struct device_attribute *devattr, const char *buf, size_t count)
578 struct fschmd_data *data = dev_get_drvdata(dev);
582 err = kstrtoul(buf, 10, &v);
586 mutex_lock(&data->update_lock);
588 reg = i2c_smbus_read_byte_data(to_i2c_client(dev), FSCHMD_REG_CONTROL);
591 reg |= FSCHMD_CONTROL_ALERT_LED;
593 reg &= ~FSCHMD_CONTROL_ALERT_LED;
595 i2c_smbus_write_byte_data(to_i2c_client(dev), FSCHMD_REG_CONTROL, reg);
597 data->global_control = reg;
599 mutex_unlock(&data->update_lock);
604 static DEVICE_ATTR(alert_led, 0644, show_alert_led, store_alert_led);
606 static struct sensor_device_attribute fschmd_attr[] = {
607 SENSOR_ATTR(in0_input, 0444, show_in_value, NULL, 0),
608 SENSOR_ATTR(in1_input, 0444, show_in_value, NULL, 1),
609 SENSOR_ATTR(in2_input, 0444, show_in_value, NULL, 2),
610 SENSOR_ATTR(in3_input, 0444, show_in_value, NULL, 3),
611 SENSOR_ATTR(in4_input, 0444, show_in_value, NULL, 4),
612 SENSOR_ATTR(in5_input, 0444, show_in_value, NULL, 5),
615 static struct sensor_device_attribute fschmd_temp_attr[] = {
616 SENSOR_ATTR(temp1_input, 0444, show_temp_value, NULL, 0),
617 SENSOR_ATTR(temp1_max, 0644, show_temp_max, store_temp_max, 0),
618 SENSOR_ATTR(temp1_fault, 0444, show_temp_fault, NULL, 0),
619 SENSOR_ATTR(temp1_alarm, 0444, show_temp_alarm, NULL, 0),
620 SENSOR_ATTR(temp2_input, 0444, show_temp_value, NULL, 1),
621 SENSOR_ATTR(temp2_max, 0644, show_temp_max, store_temp_max, 1),
622 SENSOR_ATTR(temp2_fault, 0444, show_temp_fault, NULL, 1),
623 SENSOR_ATTR(temp2_alarm, 0444, show_temp_alarm, NULL, 1),
624 SENSOR_ATTR(temp3_input, 0444, show_temp_value, NULL, 2),
625 SENSOR_ATTR(temp3_max, 0644, show_temp_max, store_temp_max, 2),
626 SENSOR_ATTR(temp3_fault, 0444, show_temp_fault, NULL, 2),
627 SENSOR_ATTR(temp3_alarm, 0444, show_temp_alarm, NULL, 2),
628 SENSOR_ATTR(temp4_input, 0444, show_temp_value, NULL, 3),
629 SENSOR_ATTR(temp4_max, 0644, show_temp_max, store_temp_max, 3),
630 SENSOR_ATTR(temp4_fault, 0444, show_temp_fault, NULL, 3),
631 SENSOR_ATTR(temp4_alarm, 0444, show_temp_alarm, NULL, 3),
632 SENSOR_ATTR(temp5_input, 0444, show_temp_value, NULL, 4),
633 SENSOR_ATTR(temp5_max, 0644, show_temp_max, store_temp_max, 4),
634 SENSOR_ATTR(temp5_fault, 0444, show_temp_fault, NULL, 4),
635 SENSOR_ATTR(temp5_alarm, 0444, show_temp_alarm, NULL, 4),
636 SENSOR_ATTR(temp6_input, 0444, show_temp_value, NULL, 5),
637 SENSOR_ATTR(temp6_max, 0644, show_temp_max, store_temp_max, 5),
638 SENSOR_ATTR(temp6_fault, 0444, show_temp_fault, NULL, 5),
639 SENSOR_ATTR(temp6_alarm, 0444, show_temp_alarm, NULL, 5),
640 SENSOR_ATTR(temp7_input, 0444, show_temp_value, NULL, 6),
641 SENSOR_ATTR(temp7_max, 0644, show_temp_max, store_temp_max, 6),
642 SENSOR_ATTR(temp7_fault, 0444, show_temp_fault, NULL, 6),
643 SENSOR_ATTR(temp7_alarm, 0444, show_temp_alarm, NULL, 6),
644 SENSOR_ATTR(temp8_input, 0444, show_temp_value, NULL, 7),
645 SENSOR_ATTR(temp8_max, 0644, show_temp_max, store_temp_max, 7),
646 SENSOR_ATTR(temp8_fault, 0444, show_temp_fault, NULL, 7),
647 SENSOR_ATTR(temp8_alarm, 0444, show_temp_alarm, NULL, 7),
648 SENSOR_ATTR(temp9_input, 0444, show_temp_value, NULL, 8),
649 SENSOR_ATTR(temp9_max, 0644, show_temp_max, store_temp_max, 8),
650 SENSOR_ATTR(temp9_fault, 0444, show_temp_fault, NULL, 8),
651 SENSOR_ATTR(temp9_alarm, 0444, show_temp_alarm, NULL, 8),
652 SENSOR_ATTR(temp10_input, 0444, show_temp_value, NULL, 9),
653 SENSOR_ATTR(temp10_max, 0644, show_temp_max, store_temp_max, 9),
654 SENSOR_ATTR(temp10_fault, 0444, show_temp_fault, NULL, 9),
655 SENSOR_ATTR(temp10_alarm, 0444, show_temp_alarm, NULL, 9),
656 SENSOR_ATTR(temp11_input, 0444, show_temp_value, NULL, 10),
657 SENSOR_ATTR(temp11_max, 0644, show_temp_max, store_temp_max, 10),
658 SENSOR_ATTR(temp11_fault, 0444, show_temp_fault, NULL, 10),
659 SENSOR_ATTR(temp11_alarm, 0444, show_temp_alarm, NULL, 10),
662 static struct sensor_device_attribute fschmd_fan_attr[] = {
663 SENSOR_ATTR(fan1_input, 0444, show_fan_value, NULL, 0),
664 SENSOR_ATTR(fan1_div, 0644, show_fan_div, store_fan_div, 0),
665 SENSOR_ATTR(fan1_alarm, 0444, show_fan_alarm, NULL, 0),
666 SENSOR_ATTR(fan1_fault, 0444, show_fan_fault, NULL, 0),
667 SENSOR_ATTR(pwm1_auto_point1_pwm, 0644, show_pwm_auto_point1_pwm,
668 store_pwm_auto_point1_pwm, 0),
669 SENSOR_ATTR(fan2_input, 0444, show_fan_value, NULL, 1),
670 SENSOR_ATTR(fan2_div, 0644, show_fan_div, store_fan_div, 1),
671 SENSOR_ATTR(fan2_alarm, 0444, show_fan_alarm, NULL, 1),
672 SENSOR_ATTR(fan2_fault, 0444, show_fan_fault, NULL, 1),
673 SENSOR_ATTR(pwm2_auto_point1_pwm, 0644, show_pwm_auto_point1_pwm,
674 store_pwm_auto_point1_pwm, 1),
675 SENSOR_ATTR(fan3_input, 0444, show_fan_value, NULL, 2),
676 SENSOR_ATTR(fan3_div, 0644, show_fan_div, store_fan_div, 2),
677 SENSOR_ATTR(fan3_alarm, 0444, show_fan_alarm, NULL, 2),
678 SENSOR_ATTR(fan3_fault, 0444, show_fan_fault, NULL, 2),
679 SENSOR_ATTR(pwm3_auto_point1_pwm, 0644, show_pwm_auto_point1_pwm,
680 store_pwm_auto_point1_pwm, 2),
681 SENSOR_ATTR(fan4_input, 0444, show_fan_value, NULL, 3),
682 SENSOR_ATTR(fan4_div, 0644, show_fan_div, store_fan_div, 3),
683 SENSOR_ATTR(fan4_alarm, 0444, show_fan_alarm, NULL, 3),
684 SENSOR_ATTR(fan4_fault, 0444, show_fan_fault, NULL, 3),
685 SENSOR_ATTR(pwm4_auto_point1_pwm, 0644, show_pwm_auto_point1_pwm,
686 store_pwm_auto_point1_pwm, 3),
687 SENSOR_ATTR(fan5_input, 0444, show_fan_value, NULL, 4),
688 SENSOR_ATTR(fan5_div, 0644, show_fan_div, store_fan_div, 4),
689 SENSOR_ATTR(fan5_alarm, 0444, show_fan_alarm, NULL, 4),
690 SENSOR_ATTR(fan5_fault, 0444, show_fan_fault, NULL, 4),
691 SENSOR_ATTR(pwm5_auto_point1_pwm, 0644, show_pwm_auto_point1_pwm,
692 store_pwm_auto_point1_pwm, 4),
693 SENSOR_ATTR(fan6_input, 0444, show_fan_value, NULL, 5),
694 SENSOR_ATTR(fan6_div, 0644, show_fan_div, store_fan_div, 5),
695 SENSOR_ATTR(fan6_alarm, 0444, show_fan_alarm, NULL, 5),
696 SENSOR_ATTR(fan6_fault, 0444, show_fan_fault, NULL, 5),
697 SENSOR_ATTR(pwm6_auto_point1_pwm, 0644, show_pwm_auto_point1_pwm,
698 store_pwm_auto_point1_pwm, 5),
699 SENSOR_ATTR(fan7_input, 0444, show_fan_value, NULL, 6),
700 SENSOR_ATTR(fan7_div, 0644, show_fan_div, store_fan_div, 6),
701 SENSOR_ATTR(fan7_alarm, 0444, show_fan_alarm, NULL, 6),
702 SENSOR_ATTR(fan7_fault, 0444, show_fan_fault, NULL, 6),
703 SENSOR_ATTR(pwm7_auto_point1_pwm, 0644, show_pwm_auto_point1_pwm,
704 store_pwm_auto_point1_pwm, 6),
712 static int watchdog_set_timeout(struct fschmd_data *data, int timeout)
715 int kind = data->kind + 1; /* 0-x array index -> 1-x module param */
717 /* 2 second or 60 second resolution? */
718 if (timeout <= 510 || kind == fscpos || kind == fscscy)
723 if (timeout < resolution || timeout > (resolution * 255))
726 mutex_lock(&data->watchdog_lock);
733 data->watchdog_control &= ~FSCHMD_WDOG_CONTROL_RESOLUTION;
735 data->watchdog_control |= FSCHMD_WDOG_CONTROL_RESOLUTION;
737 data->watchdog_preset = DIV_ROUND_UP(timeout, resolution);
739 /* Write new timeout value */
740 i2c_smbus_write_byte_data(data->client,
741 FSCHMD_REG_WDOG_PRESET[data->kind], data->watchdog_preset);
742 /* Write new control register, do not trigger! */
743 i2c_smbus_write_byte_data(data->client,
744 FSCHMD_REG_WDOG_CONTROL[data->kind],
745 data->watchdog_control & ~FSCHMD_WDOG_CONTROL_TRIGGER);
747 ret = data->watchdog_preset * resolution;
750 mutex_unlock(&data->watchdog_lock);
754 static int watchdog_get_timeout(struct fschmd_data *data)
758 mutex_lock(&data->watchdog_lock);
759 if (data->watchdog_control & FSCHMD_WDOG_CONTROL_RESOLUTION)
760 timeout = data->watchdog_preset * 60;
762 timeout = data->watchdog_preset * 2;
763 mutex_unlock(&data->watchdog_lock);
768 static int watchdog_trigger(struct fschmd_data *data)
772 mutex_lock(&data->watchdog_lock);
778 data->watchdog_control |= FSCHMD_WDOG_CONTROL_TRIGGER;
779 i2c_smbus_write_byte_data(data->client,
780 FSCHMD_REG_WDOG_CONTROL[data->kind],
781 data->watchdog_control);
783 mutex_unlock(&data->watchdog_lock);
787 static int watchdog_stop(struct fschmd_data *data)
791 mutex_lock(&data->watchdog_lock);
797 data->watchdog_control &= ~FSCHMD_WDOG_CONTROL_STARTED;
799 * Don't store the stop flag in our watchdog control register copy, as
800 * its a write only bit (read always returns 0)
802 i2c_smbus_write_byte_data(data->client,
803 FSCHMD_REG_WDOG_CONTROL[data->kind],
804 data->watchdog_control | FSCHMD_WDOG_CONTROL_STOP);
806 mutex_unlock(&data->watchdog_lock);
810 static int watchdog_open(struct inode *inode, struct file *filp)
812 struct fschmd_data *pos, *data = NULL;
813 int watchdog_is_open;
816 * We get called from drivers/char/misc.c with misc_mtx hold, and we
817 * call misc_register() from fschmd_probe() with watchdog_data_mutex
818 * hold, as misc_register() takes the misc_mtx lock, this is a possible
819 * deadlock, so we use mutex_trylock here.
821 if (!mutex_trylock(&watchdog_data_mutex))
823 list_for_each_entry(pos, &watchdog_data_list, list) {
824 if (pos->watchdog_miscdev.minor == iminor(inode)) {
829 /* Note we can never not have found data, so we don't check for this */
830 watchdog_is_open = test_and_set_bit(0, &data->watchdog_is_open);
831 if (!watchdog_is_open)
832 kref_get(&data->kref);
833 mutex_unlock(&watchdog_data_mutex);
835 if (watchdog_is_open)
838 /* Start the watchdog */
839 watchdog_trigger(data);
840 filp->private_data = data;
842 return nonseekable_open(inode, filp);
845 static int watchdog_release(struct inode *inode, struct file *filp)
847 struct fschmd_data *data = filp->private_data;
849 if (data->watchdog_expect_close) {
851 data->watchdog_expect_close = 0;
853 watchdog_trigger(data);
854 dev_crit(&data->client->dev,
855 "unexpected close, not stopping watchdog!\n");
858 clear_bit(0, &data->watchdog_is_open);
860 mutex_lock(&watchdog_data_mutex);
861 kref_put(&data->kref, fschmd_release_resources);
862 mutex_unlock(&watchdog_data_mutex);
867 static ssize_t watchdog_write(struct file *filp, const char __user *buf,
868 size_t count, loff_t *offset)
871 struct fschmd_data *data = filp->private_data;
877 /* Clear it in case it was set with a previous write */
878 data->watchdog_expect_close = 0;
880 for (i = 0; i != count; i++) {
882 if (get_user(c, buf + i))
885 data->watchdog_expect_close = 1;
888 ret = watchdog_trigger(data);
895 static long watchdog_ioctl(struct file *filp, unsigned int cmd,
898 struct watchdog_info ident = {
899 .options = WDIOF_KEEPALIVEPING | WDIOF_SETTIMEOUT |
901 .identity = "FSC watchdog"
904 struct fschmd_data *data = filp->private_data;
907 case WDIOC_GETSUPPORT:
908 ident.firmware_version = data->revision;
910 ident.options |= WDIOF_MAGICCLOSE;
911 if (copy_to_user((void __user *)arg, &ident, sizeof(ident)))
915 case WDIOC_GETSTATUS:
916 ret = put_user(0, (int __user *)arg);
919 case WDIOC_GETBOOTSTATUS:
920 if (data->watchdog_state & FSCHMD_WDOG_STATE_CARDRESET)
921 ret = put_user(WDIOF_CARDRESET, (int __user *)arg);
923 ret = put_user(0, (int __user *)arg);
926 case WDIOC_KEEPALIVE:
927 ret = watchdog_trigger(data);
930 case WDIOC_GETTIMEOUT:
931 i = watchdog_get_timeout(data);
932 ret = put_user(i, (int __user *)arg);
935 case WDIOC_SETTIMEOUT:
936 if (get_user(i, (int __user *)arg)) {
940 ret = watchdog_set_timeout(data, i);
942 ret = put_user(ret, (int __user *)arg);
945 case WDIOC_SETOPTIONS:
946 if (get_user(i, (int __user *)arg)) {
951 if (i & WDIOS_DISABLECARD)
952 ret = watchdog_stop(data);
953 else if (i & WDIOS_ENABLECARD)
954 ret = watchdog_trigger(data);
965 static const struct file_operations watchdog_fops = {
966 .owner = THIS_MODULE,
968 .open = watchdog_open,
969 .release = watchdog_release,
970 .write = watchdog_write,
971 .unlocked_ioctl = watchdog_ioctl,
976 * Detect, register, unregister and update device functions
980 * DMI decode routine to read voltage scaling factors from special DMI tables,
981 * which are available on FSC machines with an fscher or later chip.
983 static void fschmd_dmi_decode(const struct dmi_header *header, void *dummy)
985 int i, mult[3] = { 0 }, offset[3] = { 0 }, vref = 0, found = 0;
988 * dmi code ugliness, we get passed the address of the contents of
989 * a complete DMI record, but in the form of a dmi_header pointer, in
990 * reality this address holds header->length bytes of which the header
991 * are the first 4 bytes
993 u8 *dmi_data = (u8 *)header;
995 /* We are looking for OEM-specific type 185 */
996 if (header->type != 185)
1000 * we are looking for what Siemens calls "subtype" 19, the subtype
1001 * is stored in byte 5 of the dmi block
1003 if (header->length < 5 || dmi_data[4] != 19)
1007 * After the subtype comes 1 unknown byte and then blocks of 5 bytes,
1008 * consisting of what Siemens calls an "Entity" number, followed by
1009 * 2 16-bit words in LSB first order
1011 for (i = 6; (i + 4) < header->length; i += 5) {
1012 /* entity 1 - 3: voltage multiplier and offset */
1013 if (dmi_data[i] >= 1 && dmi_data[i] <= 3) {
1014 /* Our in sensors order and the DMI order differ */
1015 const int shuffle[3] = { 1, 0, 2 };
1016 int in = shuffle[dmi_data[i] - 1];
1018 /* Check for twice the same entity */
1019 if (found & (1 << in))
1022 mult[in] = dmi_data[i + 1] | (dmi_data[i + 2] << 8);
1023 offset[in] = dmi_data[i + 3] | (dmi_data[i + 4] << 8);
1028 /* entity 7: reference voltage */
1029 if (dmi_data[i] == 7) {
1030 /* Check for twice the same entity */
1034 vref = dmi_data[i + 1] | (dmi_data[i + 2] << 8);
1040 if (found == 0x0F) {
1041 for (i = 0; i < 3; i++) {
1042 dmi_mult[i] = mult[i] * 10;
1043 dmi_offset[i] = offset[i] * 10;
1046 * According to the docs there should be separate dmi entries
1047 * for the mult's and offsets of in3-5 of the syl, but on
1048 * my test machine these are not present
1050 dmi_mult[3] = dmi_mult[2];
1051 dmi_mult[4] = dmi_mult[1];
1052 dmi_mult[5] = dmi_mult[2];
1053 dmi_offset[3] = dmi_offset[2];
1054 dmi_offset[4] = dmi_offset[1];
1055 dmi_offset[5] = dmi_offset[2];
1060 static int fschmd_detect(struct i2c_client *client,
1061 struct i2c_board_info *info)
1064 struct i2c_adapter *adapter = client->adapter;
1067 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
1070 /* Detect & Identify the chip */
1071 id[0] = i2c_smbus_read_byte_data(client, FSCHMD_REG_IDENT_0);
1072 id[1] = i2c_smbus_read_byte_data(client, FSCHMD_REG_IDENT_1);
1073 id[2] = i2c_smbus_read_byte_data(client, FSCHMD_REG_IDENT_2);
1076 if (!strcmp(id, "PEG"))
1078 else if (!strcmp(id, "HER"))
1080 else if (!strcmp(id, "SCY"))
1082 else if (!strcmp(id, "HRC"))
1084 else if (!strcmp(id, "HMD"))
1086 else if (!strcmp(id, "HDS"))
1088 else if (!strcmp(id, "SYL"))
1093 strlcpy(info->type, fschmd_id[kind].name, I2C_NAME_SIZE);
1098 static int fschmd_probe(struct i2c_client *client,
1099 const struct i2c_device_id *id)
1101 struct fschmd_data *data;
1102 const char * const names[7] = { "Poseidon", "Hermes", "Scylla",
1103 "Heracles", "Heimdall", "Hades", "Syleus" };
1104 const int watchdog_minors[] = { WATCHDOG_MINOR, 212, 213, 214, 215 };
1106 enum chips kind = id->driver_data;
1108 data = kzalloc(sizeof(struct fschmd_data), GFP_KERNEL);
1112 i2c_set_clientdata(client, data);
1113 mutex_init(&data->update_lock);
1114 mutex_init(&data->watchdog_lock);
1115 INIT_LIST_HEAD(&data->list);
1116 kref_init(&data->kref);
1118 * Store client pointer in our data struct for watchdog usage
1119 * (where the client is found through a data ptr instead of the
1122 data->client = client;
1125 if (kind == fscpos) {
1127 * The Poseidon has hardwired temp limits, fill these
1128 * in for the alarm resetting code
1130 data->temp_max[0] = 70 + 128;
1131 data->temp_max[1] = 50 + 128;
1132 data->temp_max[2] = 50 + 128;
1135 /* Read the special DMI table for fscher and newer chips */
1136 if ((kind == fscher || kind >= fschrc) && dmi_vref == -1) {
1137 dmi_walk(fschmd_dmi_decode, NULL);
1138 if (dmi_vref == -1) {
1139 dev_warn(&client->dev,
1140 "Couldn't get voltage scaling factors from "
1141 "BIOS DMI table, using builtin defaults\n");
1146 /* Read in some never changing registers */
1147 data->revision = i2c_smbus_read_byte_data(client, FSCHMD_REG_REVISION);
1148 data->global_control = i2c_smbus_read_byte_data(client,
1149 FSCHMD_REG_CONTROL);
1150 data->watchdog_control = i2c_smbus_read_byte_data(client,
1151 FSCHMD_REG_WDOG_CONTROL[data->kind]);
1152 data->watchdog_state = i2c_smbus_read_byte_data(client,
1153 FSCHMD_REG_WDOG_STATE[data->kind]);
1154 data->watchdog_preset = i2c_smbus_read_byte_data(client,
1155 FSCHMD_REG_WDOG_PRESET[data->kind]);
1157 err = device_create_file(&client->dev, &dev_attr_alert_led);
1161 for (i = 0; i < FSCHMD_NO_VOLT_SENSORS[data->kind]; i++) {
1162 err = device_create_file(&client->dev,
1163 &fschmd_attr[i].dev_attr);
1168 for (i = 0; i < (FSCHMD_NO_TEMP_SENSORS[data->kind] * 4); i++) {
1169 /* Poseidon doesn't have TEMP_LIMIT registers */
1170 if (kind == fscpos && fschmd_temp_attr[i].dev_attr.show ==
1174 if (kind == fscsyl) {
1176 data->temp_status[i / 4] =
1177 i2c_smbus_read_byte_data(client,
1178 FSCHMD_REG_TEMP_STATE
1179 [data->kind][i / 4]);
1180 if (data->temp_status[i / 4] & FSCHMD_TEMP_DISABLED)
1184 err = device_create_file(&client->dev,
1185 &fschmd_temp_attr[i].dev_attr);
1190 for (i = 0; i < (FSCHMD_NO_FAN_SENSORS[data->kind] * 5); i++) {
1191 /* Poseidon doesn't have a FAN_MIN register for its 3rd fan */
1192 if (kind == fscpos &&
1193 !strcmp(fschmd_fan_attr[i].dev_attr.attr.name,
1194 "pwm3_auto_point1_pwm"))
1197 if (kind == fscsyl) {
1199 data->fan_status[i / 5] =
1200 i2c_smbus_read_byte_data(client,
1201 FSCHMD_REG_FAN_STATE
1202 [data->kind][i / 5]);
1203 if (data->fan_status[i / 5] & FSCHMD_FAN_DISABLED)
1207 err = device_create_file(&client->dev,
1208 &fschmd_fan_attr[i].dev_attr);
1213 data->hwmon_dev = hwmon_device_register(&client->dev);
1214 if (IS_ERR(data->hwmon_dev)) {
1215 err = PTR_ERR(data->hwmon_dev);
1216 data->hwmon_dev = NULL;
1221 * We take the data_mutex lock early so that watchdog_open() cannot
1222 * run when misc_register() has completed, but we've not yet added
1223 * our data to the watchdog_data_list (and set the default timeout)
1225 mutex_lock(&watchdog_data_mutex);
1226 for (i = 0; i < ARRAY_SIZE(watchdog_minors); i++) {
1227 /* Register our watchdog part */
1228 snprintf(data->watchdog_name, sizeof(data->watchdog_name),
1229 "watchdog%c", (i == 0) ? '\0' : ('0' + i));
1230 data->watchdog_miscdev.name = data->watchdog_name;
1231 data->watchdog_miscdev.fops = &watchdog_fops;
1232 data->watchdog_miscdev.minor = watchdog_minors[i];
1233 err = misc_register(&data->watchdog_miscdev);
1237 data->watchdog_miscdev.minor = 0;
1238 dev_err(&client->dev,
1239 "Registering watchdog chardev: %d\n", err);
1243 list_add(&data->list, &watchdog_data_list);
1244 watchdog_set_timeout(data, 60);
1245 dev_info(&client->dev,
1246 "Registered watchdog chardev major 10, minor: %d\n",
1247 watchdog_minors[i]);
1250 if (i == ARRAY_SIZE(watchdog_minors)) {
1251 data->watchdog_miscdev.minor = 0;
1252 dev_warn(&client->dev, "Couldn't register watchdog chardev "
1253 "(due to no free minor)\n");
1255 mutex_unlock(&watchdog_data_mutex);
1257 dev_info(&client->dev, "Detected FSC %s chip, revision: %d\n",
1258 names[data->kind], (int) data->revision);
1263 fschmd_remove(client); /* will also free data for us */
1267 static int fschmd_remove(struct i2c_client *client)
1269 struct fschmd_data *data = i2c_get_clientdata(client);
1272 /* Unregister the watchdog (if registered) */
1273 if (data->watchdog_miscdev.minor) {
1274 misc_deregister(&data->watchdog_miscdev);
1275 if (data->watchdog_is_open) {
1276 dev_warn(&client->dev,
1277 "i2c client detached with watchdog open! "
1278 "Stopping watchdog.\n");
1279 watchdog_stop(data);
1281 mutex_lock(&watchdog_data_mutex);
1282 list_del(&data->list);
1283 mutex_unlock(&watchdog_data_mutex);
1284 /* Tell the watchdog code the client is gone */
1285 mutex_lock(&data->watchdog_lock);
1286 data->client = NULL;
1287 mutex_unlock(&data->watchdog_lock);
1291 * Check if registered in case we're called from fschmd_detect
1292 * to cleanup after an error
1294 if (data->hwmon_dev)
1295 hwmon_device_unregister(data->hwmon_dev);
1297 device_remove_file(&client->dev, &dev_attr_alert_led);
1298 for (i = 0; i < (FSCHMD_NO_VOLT_SENSORS[data->kind]); i++)
1299 device_remove_file(&client->dev, &fschmd_attr[i].dev_attr);
1300 for (i = 0; i < (FSCHMD_NO_TEMP_SENSORS[data->kind] * 4); i++)
1301 device_remove_file(&client->dev,
1302 &fschmd_temp_attr[i].dev_attr);
1303 for (i = 0; i < (FSCHMD_NO_FAN_SENSORS[data->kind] * 5); i++)
1304 device_remove_file(&client->dev,
1305 &fschmd_fan_attr[i].dev_attr);
1307 mutex_lock(&watchdog_data_mutex);
1308 kref_put(&data->kref, fschmd_release_resources);
1309 mutex_unlock(&watchdog_data_mutex);
1314 static struct fschmd_data *fschmd_update_device(struct device *dev)
1316 struct i2c_client *client = to_i2c_client(dev);
1317 struct fschmd_data *data = i2c_get_clientdata(client);
1320 mutex_lock(&data->update_lock);
1322 if (time_after(jiffies, data->last_updated + 2 * HZ) || !data->valid) {
1324 for (i = 0; i < FSCHMD_NO_TEMP_SENSORS[data->kind]; i++) {
1325 data->temp_act[i] = i2c_smbus_read_byte_data(client,
1326 FSCHMD_REG_TEMP_ACT[data->kind][i]);
1327 data->temp_status[i] = i2c_smbus_read_byte_data(client,
1328 FSCHMD_REG_TEMP_STATE[data->kind][i]);
1330 /* The fscpos doesn't have TEMP_LIMIT registers */
1331 if (FSCHMD_REG_TEMP_LIMIT[data->kind][i])
1332 data->temp_max[i] = i2c_smbus_read_byte_data(
1334 FSCHMD_REG_TEMP_LIMIT[data->kind][i]);
1337 * reset alarm if the alarm condition is gone,
1338 * the chip doesn't do this itself
1340 if ((data->temp_status[i] & FSCHMD_TEMP_ALARM_MASK) ==
1341 FSCHMD_TEMP_ALARM_MASK &&
1342 data->temp_act[i] < data->temp_max[i])
1343 i2c_smbus_write_byte_data(client,
1344 FSCHMD_REG_TEMP_STATE[data->kind][i],
1345 data->temp_status[i]);
1348 for (i = 0; i < FSCHMD_NO_FAN_SENSORS[data->kind]; i++) {
1349 data->fan_act[i] = i2c_smbus_read_byte_data(client,
1350 FSCHMD_REG_FAN_ACT[data->kind][i]);
1351 data->fan_status[i] = i2c_smbus_read_byte_data(client,
1352 FSCHMD_REG_FAN_STATE[data->kind][i]);
1353 data->fan_ripple[i] = i2c_smbus_read_byte_data(client,
1354 FSCHMD_REG_FAN_RIPPLE[data->kind][i]);
1356 /* The fscpos third fan doesn't have a fan_min */
1357 if (FSCHMD_REG_FAN_MIN[data->kind][i])
1358 data->fan_min[i] = i2c_smbus_read_byte_data(
1360 FSCHMD_REG_FAN_MIN[data->kind][i]);
1362 /* reset fan status if speed is back to > 0 */
1363 if ((data->fan_status[i] & FSCHMD_FAN_ALARM) &&
1365 i2c_smbus_write_byte_data(client,
1366 FSCHMD_REG_FAN_STATE[data->kind][i],
1367 data->fan_status[i]);
1370 for (i = 0; i < FSCHMD_NO_VOLT_SENSORS[data->kind]; i++)
1371 data->volt[i] = i2c_smbus_read_byte_data(client,
1372 FSCHMD_REG_VOLT[data->kind][i]);
1374 data->last_updated = jiffies;
1378 mutex_unlock(&data->update_lock);
1383 module_i2c_driver(fschmd_driver);
1385 MODULE_AUTHOR("Hans de Goede <hdegoede@redhat.com>");
1386 MODULE_DESCRIPTION("FSC Poseidon, Hermes, Scylla, Heracles, Heimdall, Hades "
1387 "and Syleus driver");
1388 MODULE_LICENSE("GPL");