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