git.oblomov.eu Git - linux-2.6/blob - drivers/hwmon/fschmd.c

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