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