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