drivers/hwmon/fschmd.c

   1 /* fschmd.c
   2  *
   3  * Copyright (C) 2007 - 2009 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, Heimdall, Hades and Syleus 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_7(fscpos, fscher, fscscy, fschrc, fschmd, fschds, fscsyl);
  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 static const u8 FSCHMD_REG_WDOG_CONTROL[7] =
  79         { 0x21, 0x21, 0x21, 0x21, 0x21, 0x28, 0x28 };
  80 static const u8 FSCHMD_REG_WDOG_STATE[7] =
  81         { 0x23, 0x23, 0x23, 0x23, 0x23, 0x29, 0x29 };
  82 static const u8 FSCHMD_REG_WDOG_PRESET[7] =
  83         { 0x28, 0x28, 0x28, 0x28, 0x28, 0x2a, 0x2a };
  84
  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
  92 /* voltages, weird order is to keep the same order as the old drivers */
  93 static const u8 FSCHMD_REG_VOLT[7][6] = {
  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 */
  99         { 0x21, 0x20, 0x22 },                           /* hds */
 100         { 0x21, 0x20, 0x22, 0x23, 0x24, 0x25 },         /* syl */
 101 };
 102
 103 static const int FSCHMD_NO_VOLT_SENSORS[7] = { 3, 3, 3, 3, 3, 3, 6 };
 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.
 107    Also notice that with the scy the sensor order is different than with the
 108    other chips, this order was in the 2.4 driver and kept for consistency. */
 109 static const u8 FSCHMD_REG_FAN_MIN[7][7] = {
 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 */
 115         { 0x55, 0x65, 0xa5, 0xb5, 0xc5 },               /* hds */
 116         { 0x54, 0x64, 0x74, 0x84, 0x94, 0xa4, 0xb4 },   /* syl */
 117 };
 118
 119 /* actual fan speed */
 120 static const u8 FSCHMD_REG_FAN_ACT[7][7] = {
 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 */
 126         { 0x5b, 0x6b, 0xab, 0xbb, 0xcb },               /* hds */
 127         { 0x57, 0x67, 0x77, 0x87, 0x97, 0xa7, 0xb7 },   /* syl */
 128 };
 129
 130 /* fan status registers */
 131 static const u8 FSCHMD_REG_FAN_STATE[7][7] = {
 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 */
 137         { 0x52, 0x62, 0xa2, 0xb2, 0xc2 },               /* hds */
 138         { 0x50, 0x60, 0x70, 0x80, 0x90, 0xa0, 0xb0 },   /* syl */
 139 };
 140
 141 /* fan ripple / divider registers */
 142 static const u8 FSCHMD_REG_FAN_RIPPLE[7][7] = {
 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 */
 148         { 0x5f, 0x6f, 0xaf, 0xbf, 0xcf },               /* hds */
 149         { 0x56, 0x66, 0x76, 0x86, 0x96, 0xa6, 0xb6 },   /* syl */
 150 };
 151
 152 static const int FSCHMD_NO_FAN_SENSORS[7] = { 3, 3, 6, 4, 5, 5, 7 };
 153
 154 /* Fan status register bitmasks */
 155 #define FSCHMD_FAN_ALARM        0x04 /* called fault by FSC! */
 156 #define FSCHMD_FAN_NOT_PRESENT  0x08
 157 #define FSCHMD_FAN_DISABLED     0x80
 158
 159
 160 /* actual temperature registers */
 161 static const u8 FSCHMD_REG_TEMP_ACT[7][11] = {
 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 */
 167         { 0x70, 0x80, 0x90, 0xd0, 0xe0 },               /* hds */
 168         { 0x58, 0x68, 0x78, 0x88, 0x98, 0xa8,           /* syl */
 169           0xb8, 0xc8, 0xd8, 0xe8, 0xf8 },
 170 };
 171
 172 /* temperature state registers */
 173 static const u8 FSCHMD_REG_TEMP_STATE[7][11] = {
 174         { 0x71, 0x81, 0x91 },                           /* pos */
 175         { 0x71, 0x81, 0x91 },                           /* her */
 176         { 0x71, 0xd1, 0x81, 0x91 },                     /* scy */
 177         { 0x71, 0x81, 0x91 },                           /* hrc */
 178         { 0x71, 0x81, 0x91, 0xd1, 0xe1 },               /* hmd */
 179         { 0x71, 0x81, 0x91, 0xd1, 0xe1 },               /* hds */
 180         { 0x59, 0x69, 0x79, 0x89, 0x99, 0xa9,           /* syl */
 181           0xb9, 0xc9, 0xd9, 0xe9, 0xf9 },
 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?? */
 189 static const u8 FSCHMD_REG_TEMP_LIMIT[7][11] = {
 190         { 0, 0, 0 },                                    /* pos */
 191         { 0x76, 0x86, 0x96 },                           /* her */
 192         { 0x76, 0xd6, 0x86, 0x96 },                     /* scy */
 193         { 0x76, 0x86, 0x96 },                           /* hrc */
 194         { 0x76, 0x86, 0x96, 0xd6, 0xe6 },               /* hmd */
 195         { 0x76, 0x86, 0x96, 0xd6, 0xe6 },               /* hds */
 196         { 0x5a, 0x6a, 0x7a, 0x8a, 0x9a, 0xaa,           /* syl */
 197           0xba, 0xca, 0xda, 0xea, 0xfa },
 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.
 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.
 205 static const u8 FSCHER_REG_TEMP_AUTOP1[] =      { 0x73, 0x83, 0x93 };
 206 static const u8 FSCHER_REG_TEMP_AUTOP2[] =      { 0x75, 0x85, 0x95 }; */
 207
 208 static const int FSCHMD_NO_TEMP_SENSORS[7] = { 3, 3, 4, 3, 5, 5, 11 };
 209
 210 /* temp status register bitmasks */
 211 #define FSCHMD_TEMP_WORKING     0x01
 212 #define FSCHMD_TEMP_ALERT       0x02
 213 #define FSCHMD_TEMP_DISABLED    0x80
 214 /* there only really is an alarm if the sensor is working and alert == 1 */
 215 #define FSCHMD_TEMP_ALARM_MASK \
 216         (FSCHMD_TEMP_WORKING | FSCHMD_TEMP_ALERT)
 217
 218 /*
 219  * Functions declarations
 220  */
 221
 222 static int fschmd_probe(struct i2c_client *client,
 223                         const struct i2c_device_id *id);
 224 static int fschmd_detect(struct i2c_client *client, int kind,
 225                          struct i2c_board_info *info);
 226 static int fschmd_remove(struct i2c_client *client);
 227 static struct fschmd_data *fschmd_update_device(struct device *dev);
 228
 229 /*
 230  * Driver data (common to all clients)
 231  */
 232
 233 static const struct i2c_device_id fschmd_id[] = {
 234         { "fscpos", fscpos },
 235         { "fscher", fscher },
 236         { "fscscy", fscscy },
 237         { "fschrc", fschrc },
 238         { "fschmd", fschmd },
 239         { "fschds", fschds },
 240         { "fscsyl", fscsyl },
 241         { }
 242 };
 243 MODULE_DEVICE_TABLE(i2c, fschmd_id);
 244
 245 static struct i2c_driver fschmd_driver = {
 246         .class          = I2C_CLASS_HWMON,
 247         .driver = {
 248                 .name   = "fschmd",
 249         },
 250         .probe          = fschmd_probe,
 251         .remove         = fschmd_remove,
 252         .id_table       = fschmd_id,
 253         .detect         = fschmd_detect,
 254         .address_data   = &addr_data,
 255 };
 256
 257 /*
 258  * Client data (each client gets its own)
 259  */
 260
 261 struct fschmd_data {
 262         struct i2c_client *client;
 263         struct device *hwmon_dev;
 264         struct mutex update_lock;
 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;
 269         int kind;
 270         unsigned long watchdog_is_open;
 271         char watchdog_expect_close;
 272         char watchdog_name[10]; /* must be unique to avoid sysfs conflict */
 273         char valid; /* zero until following fields are valid */
 274         unsigned long last_updated; /* in jiffies */
 275
 276         /* register values */
 277         u8 revision;            /* chip revision */
 278         u8 global_control;      /* global control register */
 279         u8 watchdog_control;    /* watchdog control register */
 280         u8 watchdog_state;      /* watchdog status register */
 281         u8 watchdog_preset;     /* watchdog counter preset on trigger val */
 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 */
 290 };
 291
 292 /* Global variables to hold information read from special DMI tables, which are
 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. */
 297 static int dmi_mult[6] = { 490, 200, 100, 100, 200, 100 };
 298 static int dmi_offset[6] = { 0, 0, 0, 0, 0, 0 };
 299 static int dmi_vref = -1;
 300
 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. */
 304 static LIST_HEAD(watchdog_data_list);
 305 /* Note this lock not only protect list access, but also data.kref access */
 306 static 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 */
 310 static void fschmd_release_resources(struct kref *ref)
 311 {
 312         struct fschmd_data *data = container_of(ref, struct fschmd_data, kref);
 313         kfree(data);
 314 }
 315
 316 /*
 317  * Sysfs attr show / store functions
 318  */
 319
 320 static 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
 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);
 334 }
 335
 336
 337 #define TEMP_FROM_REG(val)      (((val) - 128) * 1000)
 338
 339 static 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
 348 static 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
 357 static 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);
 367         i2c_smbus_write_byte_data(to_i2c_client(dev),
 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
 375 static 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! */
 382         if (data->temp_status[index] & FSCHMD_TEMP_WORKING)
 383                 return sprintf(buf, "0\n");
 384         else
 385                 return sprintf(buf, "1\n");
 386 }
 387
 388 static 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
 404 static 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
 413 static 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
 423 static 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
 444         reg = i2c_smbus_read_byte_data(to_i2c_client(dev),
 445                 FSCHMD_REG_FAN_RIPPLE[data->kind][index]);
 446
 447         /* bits 2..7 reserved => mask with 0x03 */
 448         reg &= ~0x03;
 449         reg |= v;
 450
 451         i2c_smbus_write_byte_data(to_i2c_client(dev),
 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
 461 static 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
 467         if (data->fan_status[index] & FSCHMD_FAN_ALARM)
 468                 return sprintf(buf, "1\n");
 469         else
 470                 return sprintf(buf, "0\n");
 471 }
 472
 473 static 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
 479         if (data->fan_status[index] & FSCHMD_FAN_NOT_PRESENT)
 480                 return sprintf(buf, "1\n");
 481         else
 482                 return sprintf(buf, "0\n");
 483 }
 484
 485
 486 static 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;
 490         struct fschmd_data *data = fschmd_update_device(dev);
 491         int val = data->fan_min[index];
 492
 493         /* 0 = allow turning off (except on the syl), 1-255 = 50-100% */
 494         if (val || data->kind == fscsyl - 1)
 495                 val = val / 2 + 128;
 496
 497         return sprintf(buf, "%d\n", val);
 498 }
 499
 500 static 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
 507         /* reg: 0 = allow turning off (except on the syl), 1-255 = 50-100% */
 508         if (v || data->kind == fscsyl - 1) {
 509                 v = SENSORS_LIMIT(v, 128, 255);
 510                 v = (v - 128) * 2 + 1;
 511         }
 512
 513         mutex_lock(&data->update_lock);
 514
 515         i2c_smbus_write_byte_data(to_i2c_client(dev),
 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 */
 527 static 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
 532         if (data->global_control & FSCHMD_CONTROL_ALERT_LED)
 533                 return sprintf(buf, "1\n");
 534         else
 535                 return sprintf(buf, "0\n");
 536 }
 537
 538 static 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
 547         reg = i2c_smbus_read_byte_data(to_i2c_client(dev), FSCHMD_REG_CONTROL);
 548
 549         if (v)
 550                 reg |= FSCHMD_CONTROL_ALERT_LED;
 551         else
 552                 reg &= ~FSCHMD_CONTROL_ALERT_LED;
 553
 554         i2c_smbus_write_byte_data(to_i2c_client(dev), FSCHMD_REG_CONTROL, reg);
 555
 556         data->global_control = reg;
 557
 558         mutex_unlock(&data->update_lock);
 559
 560         return count;
 561 }
 562
 563 static DEVICE_ATTR(alert_led, 0644, show_alert_led, store_alert_led);
 564
 565 static 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),
 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),
 572 };
 573
 574 static 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),
 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),
 619 };
 620
 621 static 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),
 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),
 664 };
 665
 666
 667 /*
 668  * Watchdog routines
 669  */
 670
 671 static 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 */
 699         i2c_smbus_write_byte_data(data->client,
 700                 FSCHMD_REG_WDOG_PRESET[data->kind], data->watchdog_preset);
 701         /* Write new control register, do not trigger! */
 702         i2c_smbus_write_byte_data(data->client,
 703                 FSCHMD_REG_WDOG_CONTROL[data->kind],
 704                 data->watchdog_control & ~FSCHMD_WDOG_CONTROL_TRIGGER);
 705
 706         ret = data->watchdog_preset * resolution;
 707
 708 leave:
 709         mutex_unlock(&data->watchdog_lock);
 710         return ret;
 711 }
 712
 713 static 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
 727 static 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;
 738         i2c_smbus_write_byte_data(data->client,
 739                                   FSCHMD_REG_WDOG_CONTROL[data->kind],
 740                                   data->watchdog_control);
 741 leave:
 742         mutex_unlock(&data->watchdog_lock);
 743         return ret;
 744 }
 745
 746 static 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) */
 759         i2c_smbus_write_byte_data(data->client,
 760                 FSCHMD_REG_WDOG_CONTROL[data->kind],
 761                 data->watchdog_control | FSCHMD_WDOG_CONTROL_STOP);
 762 leave:
 763         mutex_unlock(&data->watchdog_lock);
 764         return ret;
 765 }
 766
 767 static int watchdog_open(struct inode *inode, struct file *filp)
 768 {
 769         struct fschmd_data *pos, *data = NULL;
 770         int watchdog_is_open;
 771
 772         /* We get called from drivers/char/misc.c with misc_mtx hold, and we
 773            call misc_register() from fschmd_probe() with watchdog_data_mutex
 774            hold, as misc_register() takes the misc_mtx lock, this is a possible
 775            deadlock, so we use mutex_trylock here. */
 776         if (!mutex_trylock(&watchdog_data_mutex))
 777                 return -ERESTARTSYS;
 778         list_for_each_entry(pos, &watchdog_data_list, list) {
 779                 if (pos->watchdog_miscdev.minor == iminor(inode)) {
 780                         data = pos;
 781                         break;
 782                 }
 783         }
 784         /* Note we can never not have found data, so we don't check for this */
 785         watchdog_is_open = test_and_set_bit(0, &data->watchdog_is_open);
 786         if (!watchdog_is_open)
 787                 kref_get(&data->kref);
 788         mutex_unlock(&watchdog_data_mutex);
 789
 790         if (watchdog_is_open)
 791                 return -EBUSY;
 792
 793         /* Start the watchdog */
 794         watchdog_trigger(data);
 795         filp->private_data = data;
 796
 797         return nonseekable_open(inode, filp);
 798 }
 799
 800 static int watchdog_release(struct inode *inode, struct file *filp)
 801 {
 802         struct fschmd_data *data = filp->private_data;
 803
 804         if (data->watchdog_expect_close) {
 805                 watchdog_stop(data);
 806                 data->watchdog_expect_close = 0;
 807         } else {
 808                 watchdog_trigger(data);
 809                 dev_crit(&data->client->dev,
 810                         "unexpected close, not stopping watchdog!\n");
 811         }
 812
 813         clear_bit(0, &data->watchdog_is_open);
 814
 815         mutex_lock(&watchdog_data_mutex);
 816         kref_put(&data->kref, fschmd_release_resources);
 817         mutex_unlock(&watchdog_data_mutex);
 818
 819         return 0;
 820 }
 821
 822 static ssize_t watchdog_write(struct file *filp, const char __user *buf,
 823         size_t count, loff_t *offset)
 824 {
 825         int ret;
 826         struct fschmd_data *data = filp->private_data;
 827
 828         if (count) {
 829                 if (!nowayout) {
 830                         size_t i;
 831
 832                         /* Clear it in case it was set with a previous write */
 833                         data->watchdog_expect_close = 0;
 834
 835                         for (i = 0; i != count; i++) {
 836                                 char c;
 837                                 if (get_user(c, buf + i))
 838                                         return -EFAULT;
 839                                 if (c == 'V')
 840                                         data->watchdog_expect_close = 1;
 841                         }
 842                 }
 843                 ret = watchdog_trigger(data);
 844                 if (ret < 0)
 845                         return ret;
 846         }
 847         return count;
 848 }
 849
 850 static int watchdog_ioctl(struct inode *inode, struct file *filp,
 851         unsigned int cmd, unsigned long arg)
 852 {
 853         static struct watchdog_info ident = {
 854                 .options = WDIOF_KEEPALIVEPING | WDIOF_SETTIMEOUT |
 855                                 WDIOF_CARDRESET,
 856                 .identity = "FSC watchdog"
 857         };
 858         int i, ret = 0;
 859         struct fschmd_data *data = filp->private_data;
 860
 861         switch (cmd) {
 862         case WDIOC_GETSUPPORT:
 863                 ident.firmware_version = data->revision;
 864                 if (!nowayout)
 865                         ident.options |= WDIOF_MAGICCLOSE;
 866                 if (copy_to_user((void __user *)arg, &ident, sizeof(ident)))
 867                         ret = -EFAULT;
 868                 break;
 869
 870         case WDIOC_GETSTATUS:
 871                 ret = put_user(0, (int __user *)arg);
 872                 break;
 873
 874         case WDIOC_GETBOOTSTATUS:
 875                 if (data->watchdog_state & FSCHMD_WDOG_STATE_CARDRESET)
 876                         ret = put_user(WDIOF_CARDRESET, (int __user *)arg);
 877                 else
 878                         ret = put_user(0, (int __user *)arg);
 879                 break;
 880
 881         case WDIOC_KEEPALIVE:
 882                 ret = watchdog_trigger(data);
 883                 break;
 884
 885         case WDIOC_GETTIMEOUT:
 886                 i = watchdog_get_timeout(data);
 887                 ret = put_user(i, (int __user *)arg);
 888                 break;
 889
 890         case WDIOC_SETTIMEOUT:
 891                 if (get_user(i, (int __user *)arg)) {
 892                         ret = -EFAULT;
 893                         break;
 894                 }
 895                 ret = watchdog_set_timeout(data, i);
 896                 if (ret > 0)
 897                         ret = put_user(ret, (int __user *)arg);
 898                 break;
 899
 900         case WDIOC_SETOPTIONS:
 901                 if (get_user(i, (int __user *)arg)) {
 902                         ret = -EFAULT;
 903                         break;
 904                 }
 905
 906                 if (i & WDIOS_DISABLECARD)
 907                         ret = watchdog_stop(data);
 908                 else if (i & WDIOS_ENABLECARD)
 909                         ret = watchdog_trigger(data);
 910                 else
 911                         ret = -EINVAL;
 912
 913                 break;
 914         default:
 915                 ret = -ENOTTY;
 916         }
 917
 918         return ret;
 919 }
 920
 921 static const struct file_operations watchdog_fops = {
 922         .owner = THIS_MODULE,
 923         .llseek = no_llseek,
 924         .open = watchdog_open,
 925         .release = watchdog_release,
 926         .write = watchdog_write,
 927         .ioctl = watchdog_ioctl,
 928 };
 929
 930
 931 /*
 932  * Detect, register, unregister and update device functions
 933  */
 934
 935 /* DMI decode routine to read voltage scaling factors from special DMI tables,
 936    which are available on FSC machines with an fscher or later chip. */
 937 static void fschmd_dmi_decode(const struct dmi_header *header, void *dummy)
 938 {
 939         int i, mult[3] = { 0 }, offset[3] = { 0 }, vref = 0, found = 0;
 940
 941         /* dmi code ugliness, we get passed the address of the contents of
 942            a complete DMI record, but in the form of a dmi_header pointer, in
 943            reality this address holds header->length bytes of which the header
 944            are the first 4 bytes */
 945         u8 *dmi_data = (u8 *)header;
 946
 947         /* We are looking for OEM-specific type 185 */
 948         if (header->type != 185)
 949                 return;
 950
 951         /* we are looking for what Siemens calls "subtype" 19, the subtype
 952            is stored in byte 5 of the dmi block */
 953         if (header->length < 5 || dmi_data[4] != 19)
 954                 return;
 955
 956         /* After the subtype comes 1 unknown byte and then blocks of 5 bytes,
 957            consisting of what Siemens calls an "Entity" number, followed by
 958            2 16-bit words in LSB first order */
 959         for (i = 6; (i + 4) < header->length; i += 5) {
 960                 /* entity 1 - 3: voltage multiplier and offset */
 961                 if (dmi_data[i] >= 1 && dmi_data[i] <= 3) {
 962                         /* Our in sensors order and the DMI order differ */
 963                         const int shuffle[3] = { 1, 0, 2 };
 964                         int in = shuffle[dmi_data[i] - 1];
 965
 966                         /* Check for twice the same entity */
 967                         if (found & (1 << in))
 968                                 return;
 969
 970                         mult[in] = dmi_data[i + 1] | (dmi_data[i + 2] << 8);
 971                         offset[in] = dmi_data[i + 3] | (dmi_data[i + 4] << 8);
 972
 973                         found |= 1 << in;
 974                 }
 975
 976                 /* entity 7: reference voltage */
 977                 if (dmi_data[i] == 7) {
 978                         /* Check for twice the same entity */
 979                         if (found & 0x08)
 980                                 return;
 981
 982                         vref = dmi_data[i + 1] | (dmi_data[i + 2] << 8);
 983
 984                         found |= 0x08;
 985                 }
 986         }
 987
 988         if (found == 0x0F) {
 989                 for (i = 0; i < 3; i++) {
 990                         dmi_mult[i] = mult[i] * 10;
 991                         dmi_offset[i] = offset[i] * 10;
 992                 }
 993                 /* According to the docs there should be separate dmi entries
 994                    for the mult's and offsets of in3-5 of the syl, but on
 995                    my test machine these are not present */
 996                 dmi_mult[3] = dmi_mult[2];
 997                 dmi_mult[4] = dmi_mult[1];
 998                 dmi_mult[5] = dmi_mult[2];
 999                 dmi_offset[3] = dmi_offset[2];
1000                 dmi_offset[4] = dmi_offset[1];
1001                 dmi_offset[5] = dmi_offset[2];
1002                 dmi_vref = vref;
1003         }
1004 }
1005
1006 static int fschmd_detect(struct i2c_client *client, int kind,
1007                          struct i2c_board_info *info)
1008 {
1009         struct i2c_adapter *adapter = client->adapter;
1010
1011         if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
1012                 return -ENODEV;
1013
1014         /* Detect & Identify the chip */
1015         if (kind <= 0) {
1016                 char id[4];
1017
1018                 id[0] = i2c_smbus_read_byte_data(client,
1019                                 FSCHMD_REG_IDENT_0);
1020                 id[1] = i2c_smbus_read_byte_data(client,
1021                                 FSCHMD_REG_IDENT_1);
1022                 id[2] = i2c_smbus_read_byte_data(client,
1023                                 FSCHMD_REG_IDENT_2);
1024                 id[3] = '\0';
1025
1026                 if (!strcmp(id, "PEG"))
1027                         kind = fscpos;
1028                 else if (!strcmp(id, "HER"))
1029                         kind = fscher;
1030                 else if (!strcmp(id, "SCY"))
1031                         kind = fscscy;
1032                 else if (!strcmp(id, "HRC"))
1033                         kind = fschrc;
1034                 else if (!strcmp(id, "HMD"))
1035                         kind = fschmd;
1036                 else if (!strcmp(id, "HDS"))
1037                         kind = fschds;
1038                 else if (!strcmp(id, "SYL"))
1039                         kind = fscsyl;
1040                 else
1041                         return -ENODEV;
1042         }
1043
1044         strlcpy(info->type, fschmd_id[kind - 1].name, I2C_NAME_SIZE);
1045
1046         return 0;
1047 }
1048
1049 static int fschmd_probe(struct i2c_client *client,
1050                         const struct i2c_device_id *id)
1051 {
1052         struct fschmd_data *data;
1053         const char * const names[7] = { "Poseidon", "Hermes", "Scylla",
1054                                 "Heracles", "Heimdall", "Hades", "Syleus" };
1055         const int watchdog_minors[] = { WATCHDOG_MINOR, 212, 213, 214, 215 };
1056         int i, err;
1057         enum chips kind = id->driver_data;
1058
1059         data = kzalloc(sizeof(struct fschmd_data), GFP_KERNEL);
1060         if (!data)
1061                 return -ENOMEM;
1062
1063         i2c_set_clientdata(client, data);
1064         mutex_init(&data->update_lock);
1065         mutex_init(&data->watchdog_lock);
1066         INIT_LIST_HEAD(&data->list);
1067         kref_init(&data->kref);
1068         /* Store client pointer in our data struct for watchdog usage
1069            (where the client is found through a data ptr instead of the
1070            otherway around) */
1071         data->client = client;
1072
1073         if (kind == fscpos) {
1074                 /* The Poseidon has hardwired temp limits, fill these
1075                    in for the alarm resetting code */
1076                 data->temp_max[0] = 70 + 128;
1077                 data->temp_max[1] = 50 + 128;
1078                 data->temp_max[2] = 50 + 128;
1079         }
1080
1081         /* Read the special DMI table for fscher and newer chips */
1082         if ((kind == fscher || kind >= fschrc) && dmi_vref == -1) {
1083                 dmi_walk(fschmd_dmi_decode, NULL);
1084                 if (dmi_vref == -1) {
1085                         dev_warn(&client->dev,
1086                                 "Couldn't get voltage scaling factors from "
1087                                 "BIOS DMI table, using builtin defaults\n");
1088                         dmi_vref = 33;
1089                 }
1090         }
1091
1092         /* i2c kind goes from 1-6, we want from 0-5 to address arrays */
1093         data->kind = kind - 1;
1094
1095         /* Read in some never changing registers */
1096         data->revision = i2c_smbus_read_byte_data(client, FSCHMD_REG_REVISION);
1097         data->global_control = i2c_smbus_read_byte_data(client,
1098                                         FSCHMD_REG_CONTROL);
1099         data->watchdog_control = i2c_smbus_read_byte_data(client,
1100                                         FSCHMD_REG_WDOG_CONTROL[data->kind]);
1101         data->watchdog_state = i2c_smbus_read_byte_data(client,
1102                                         FSCHMD_REG_WDOG_STATE[data->kind]);
1103         data->watchdog_preset = i2c_smbus_read_byte_data(client,
1104                                         FSCHMD_REG_WDOG_PRESET[data->kind]);
1105
1106         err = device_create_file(&client->dev, &dev_attr_alert_led);
1107         if (err)
1108                 goto exit_detach;
1109
1110         for (i = 0; i < FSCHMD_NO_VOLT_SENSORS[data->kind]; i++) {
1111                 err = device_create_file(&client->dev,
1112                                         &fschmd_attr[i].dev_attr);
1113                 if (err)
1114                         goto exit_detach;
1115         }
1116
1117         for (i = 0; i < (FSCHMD_NO_TEMP_SENSORS[data->kind] * 4); i++) {
1118                 /* Poseidon doesn't have TEMP_LIMIT registers */
1119                 if (kind == fscpos && fschmd_temp_attr[i].dev_attr.show ==
1120                                 show_temp_max)
1121                         continue;
1122
1123                 if (kind == fscsyl) {
1124                         if (i % 4 == 0)
1125                                 data->temp_status[i / 4] =
1126                                         i2c_smbus_read_byte_data(client,
1127                                                 FSCHMD_REG_TEMP_STATE
1128                                                 [data->kind][i / 4]);
1129                         if (data->temp_status[i / 4] & FSCHMD_TEMP_DISABLED)
1130                                 continue;
1131                 }
1132
1133                 err = device_create_file(&client->dev,
1134                                         &fschmd_temp_attr[i].dev_attr);
1135                 if (err)
1136                         goto exit_detach;
1137         }
1138
1139         for (i = 0; i < (FSCHMD_NO_FAN_SENSORS[data->kind] * 5); i++) {
1140                 /* Poseidon doesn't have a FAN_MIN register for its 3rd fan */
1141                 if (kind == fscpos &&
1142                                 !strcmp(fschmd_fan_attr[i].dev_attr.attr.name,
1143                                         "pwm3_auto_point1_pwm"))
1144                         continue;
1145
1146                 if (kind == fscsyl) {
1147                         if (i % 5 == 0)
1148                                 data->fan_status[i / 5] =
1149                                         i2c_smbus_read_byte_data(client,
1150                                                 FSCHMD_REG_FAN_STATE
1151                                                 [data->kind][i / 5]);
1152                         if (data->fan_status[i / 5] & FSCHMD_FAN_DISABLED)
1153                                 continue;
1154                 }
1155
1156                 err = device_create_file(&client->dev,
1157                                         &fschmd_fan_attr[i].dev_attr);
1158                 if (err)
1159                         goto exit_detach;
1160         }
1161
1162         data->hwmon_dev = hwmon_device_register(&client->dev);
1163         if (IS_ERR(data->hwmon_dev)) {
1164                 err = PTR_ERR(data->hwmon_dev);
1165                 data->hwmon_dev = NULL;
1166                 goto exit_detach;
1167         }
1168
1169         /* We take the data_mutex lock early so that watchdog_open() cannot
1170            run when misc_register() has completed, but we've not yet added
1171            our data to the watchdog_data_list (and set the default timeout) */
1172         mutex_lock(&watchdog_data_mutex);
1173         for (i = 0; i < ARRAY_SIZE(watchdog_minors); i++) {
1174                 /* Register our watchdog part */
1175                 snprintf(data->watchdog_name, sizeof(data->watchdog_name),
1176                         "watchdog%c", (i == 0) ? '\0' : ('0' + i));
1177                 data->watchdog_miscdev.name = data->watchdog_name;
1178                 data->watchdog_miscdev.fops = &watchdog_fops;
1179                 data->watchdog_miscdev.minor = watchdog_minors[i];
1180                 err = misc_register(&data->watchdog_miscdev);
1181                 if (err == -EBUSY)
1182                         continue;
1183                 if (err) {
1184                         data->watchdog_miscdev.minor = 0;
1185                         dev_err(&client->dev,
1186                                 "Registering watchdog chardev: %d\n", err);
1187                         break;
1188                 }
1189
1190                 list_add(&data->list, &watchdog_data_list);
1191                 watchdog_set_timeout(data, 60);
1192                 dev_info(&client->dev,
1193                         "Registered watchdog chardev major 10, minor: %d\n",
1194                         watchdog_minors[i]);
1195                 break;
1196         }
1197         if (i == ARRAY_SIZE(watchdog_minors)) {
1198                 data->watchdog_miscdev.minor = 0;
1199                 dev_warn(&client->dev, "Couldn't register watchdog chardev "
1200                         "(due to no free minor)\n");
1201         }
1202         mutex_unlock(&watchdog_data_mutex);
1203
1204         dev_info(&client->dev, "Detected FSC %s chip, revision: %d\n",
1205                 names[data->kind], (int) data->revision);
1206
1207         return 0;
1208
1209 exit_detach:
1210         fschmd_remove(client); /* will also free data for us */
1211         return err;
1212 }
1213
1214 static int fschmd_remove(struct i2c_client *client)
1215 {
1216         struct fschmd_data *data = i2c_get_clientdata(client);
1217         int i;
1218
1219         /* Unregister the watchdog (if registered) */
1220         if (data->watchdog_miscdev.minor) {
1221                 misc_deregister(&data->watchdog_miscdev);
1222                 if (data->watchdog_is_open) {
1223                         dev_warn(&client->dev,
1224                                 "i2c client detached with watchdog open! "
1225                                 "Stopping watchdog.\n");
1226                         watchdog_stop(data);
1227                 }
1228                 mutex_lock(&watchdog_data_mutex);
1229                 list_del(&data->list);
1230                 mutex_unlock(&watchdog_data_mutex);
1231                 /* Tell the watchdog code the client is gone */
1232                 mutex_lock(&data->watchdog_lock);
1233                 data->client = NULL;
1234                 mutex_unlock(&data->watchdog_lock);
1235         }
1236
1237         /* Check if registered in case we're called from fschmd_detect
1238            to cleanup after an error */
1239         if (data->hwmon_dev)
1240                 hwmon_device_unregister(data->hwmon_dev);
1241
1242         device_remove_file(&client->dev, &dev_attr_alert_led);
1243         for (i = 0; i < (FSCHMD_NO_VOLT_SENSORS[data->kind]); i++)
1244                 device_remove_file(&client->dev, &fschmd_attr[i].dev_attr);
1245         for (i = 0; i < (FSCHMD_NO_TEMP_SENSORS[data->kind] * 4); i++)
1246                 device_remove_file(&client->dev,
1247                                         &fschmd_temp_attr[i].dev_attr);
1248         for (i = 0; i < (FSCHMD_NO_FAN_SENSORS[data->kind] * 5); i++)
1249                 device_remove_file(&client->dev,
1250                                         &fschmd_fan_attr[i].dev_attr);
1251
1252         mutex_lock(&watchdog_data_mutex);
1253         kref_put(&data->kref, fschmd_release_resources);
1254         mutex_unlock(&watchdog_data_mutex);
1255
1256         return 0;
1257 }
1258
1259 static struct fschmd_data *fschmd_update_device(struct device *dev)
1260 {
1261         struct i2c_client *client = to_i2c_client(dev);
1262         struct fschmd_data *data = i2c_get_clientdata(client);
1263         int i;
1264
1265         mutex_lock(&data->update_lock);
1266
1267         if (time_after(jiffies, data->last_updated + 2 * HZ) || !data->valid) {
1268
1269                 for (i = 0; i < FSCHMD_NO_TEMP_SENSORS[data->kind]; i++) {
1270                         data->temp_act[i] = i2c_smbus_read_byte_data(client,
1271                                         FSCHMD_REG_TEMP_ACT[data->kind][i]);
1272                         data->temp_status[i] = i2c_smbus_read_byte_data(client,
1273                                         FSCHMD_REG_TEMP_STATE[data->kind][i]);
1274
1275                         /* The fscpos doesn't have TEMP_LIMIT registers */
1276                         if (FSCHMD_REG_TEMP_LIMIT[data->kind][i])
1277                                 data->temp_max[i] = i2c_smbus_read_byte_data(
1278                                         client,
1279                                         FSCHMD_REG_TEMP_LIMIT[data->kind][i]);
1280
1281                         /* reset alarm if the alarm condition is gone,
1282                            the chip doesn't do this itself */
1283                         if ((data->temp_status[i] & FSCHMD_TEMP_ALARM_MASK) ==
1284                                         FSCHMD_TEMP_ALARM_MASK &&
1285                                         data->temp_act[i] < data->temp_max[i])
1286                                 i2c_smbus_write_byte_data(client,
1287                                         FSCHMD_REG_TEMP_STATE[data->kind][i],
1288                                         data->temp_status[i]);
1289                 }
1290
1291                 for (i = 0; i < FSCHMD_NO_FAN_SENSORS[data->kind]; i++) {
1292                         data->fan_act[i] = i2c_smbus_read_byte_data(client,
1293                                         FSCHMD_REG_FAN_ACT[data->kind][i]);
1294                         data->fan_status[i] = i2c_smbus_read_byte_data(client,
1295                                         FSCHMD_REG_FAN_STATE[data->kind][i]);
1296                         data->fan_ripple[i] = i2c_smbus_read_byte_data(client,
1297                                         FSCHMD_REG_FAN_RIPPLE[data->kind][i]);
1298
1299                         /* The fscpos third fan doesn't have a fan_min */
1300                         if (FSCHMD_REG_FAN_MIN[data->kind][i])
1301                                 data->fan_min[i] = i2c_smbus_read_byte_data(
1302                                         client,
1303                                         FSCHMD_REG_FAN_MIN[data->kind][i]);
1304
1305                         /* reset fan status if speed is back to > 0 */
1306                         if ((data->fan_status[i] & FSCHMD_FAN_ALARM) &&
1307                                         data->fan_act[i])
1308                                 i2c_smbus_write_byte_data(client,
1309                                         FSCHMD_REG_FAN_STATE[data->kind][i],
1310                                         data->fan_status[i]);
1311                 }
1312
1313                 for (i = 0; i < FSCHMD_NO_VOLT_SENSORS[data->kind]; i++)
1314                         data->volt[i] = i2c_smbus_read_byte_data(client,
1315                                                FSCHMD_REG_VOLT[data->kind][i]);
1316
1317                 data->last_updated = jiffies;
1318                 data->valid = 1;
1319         }
1320
1321         mutex_unlock(&data->update_lock);
1322
1323         return data;
1324 }
1325
1326 static int __init fschmd_init(void)
1327 {
1328         return i2c_add_driver(&fschmd_driver);
1329 }
1330
1331 static void __exit fschmd_exit(void)
1332 {
1333         i2c_del_driver(&fschmd_driver);
1334 }
1335
1336 MODULE_AUTHOR("Hans de Goede <hdegoede@redhat.com>");
1337 MODULE_DESCRIPTION("FSC Poseidon, Hermes, Scylla, Heracles, Heimdall, Hades "
1338                         "and Syleus driver");
1339 MODULE_LICENSE("GPL");
1340
1341 module_init(fschmd_init);
1342 module_exit(fschmd_exit);