drivers/hwmon/fschmd.c

   1 /* fschmd.c
   2  *
   3  * Copyright (C) 2007 Hans de Goede <j.w.r.degoede@hhs.nl>
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation; either version 2 of the License, or
   8  * (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program; if not, write to the Free Software
  17  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  18  */
  19
  20 /*
  21  *  Merged Fujitsu Siemens hwmon driver, supporting the Poseidon, Hermes,
  22  *  Scylla, Heracles and Heimdall chips
  23  *
  24  *  Based on the original 2.4 fscscy, 2.6 fscpos, 2.6 fscher and 2.6
  25  *  (candidate) fschmd drivers:
  26  *  Copyright (C) 2006 Thilo Cestonaro
  27  *                      <thilo.cestonaro.external@fujitsu-siemens.com>
  28  *  Copyright (C) 2004, 2005 Stefan Ott <stefan@desire.ch>
  29  *  Copyright (C) 2003, 2004 Reinhard Nissl <rnissl@gmx.de>
  30  *  Copyright (c) 2001 Martin Knoblauch <mkn@teraport.de, knobi@knobisoft.de>
  31  *  Copyright (C) 2000 Hermann Jung <hej@odn.de>
  32  */
  33
  34 #include <linux/module.h>
  35 #include <linux/init.h>
  36 #include <linux/slab.h>
  37 #include <linux/jiffies.h>
  38 #include <linux/i2c.h>
  39 #include <linux/hwmon.h>
  40 #include <linux/hwmon-sysfs.h>
  41 #include <linux/err.h>
  42 #include <linux/mutex.h>
  43 #include <linux/sysfs.h>
  44 #include <linux/dmi.h>
  45
  46 /* Addresses to scan */
  47 static const unsigned short normal_i2c[] = { 0x73, I2C_CLIENT_END };
  48
  49 /* Insmod parameters */
  50 I2C_CLIENT_INSMOD_5(fscpos, fscher, fscscy, fschrc, fschmd);
  51
  52 /*
  53  * The FSCHMD registers and other defines
  54  */
  55
  56 /* chip identification */
  57 #define FSCHMD_REG_IDENT_0              0x00
  58 #define FSCHMD_REG_IDENT_1              0x01
  59 #define FSCHMD_REG_IDENT_2              0x02
  60 #define FSCHMD_REG_REVISION             0x03
  61
  62 /* global control and status */
  63 #define FSCHMD_REG_EVENT_STATE          0x04
  64 #define FSCHMD_REG_CONTROL              0x05
  65
  66 #define FSCHMD_CONTROL_ALERT_LED_MASK   0x01
  67
  68 /* watchdog (support to be implemented) */
  69 #define FSCHMD_REG_WDOG_PRESET          0x28
  70 #define FSCHMD_REG_WDOG_STATE           0x23
  71 #define FSCHMD_REG_WDOG_CONTROL         0x21
  72
  73 /* voltages, weird order is to keep the same order as the old drivers */
  74 static const u8 FSCHMD_REG_VOLT[3] = { 0x45, 0x42, 0x48 };
  75
  76 /* minimum pwm at which the fan is driven (pwm can by increased depending on
  77    the temp. Notice that for the scy some fans share there minimum speed.
  78    Also notice that with the scy the sensor order is different then with the
  79    other chips, this order was in the 2.4 driver and kept for consistency. */
  80 static const u8 FSCHMD_REG_FAN_MIN[5][6] = {
  81         { 0x55, 0x65 },                                 /* pos */
  82         { 0x55, 0x65, 0xb5 },                           /* her */
  83         { 0x65, 0x65, 0x55, 0xa5, 0x55, 0xa5 },         /* scy */
  84         { 0x55, 0x65, 0xa5, 0xb5 },                     /* hrc */
  85         { 0x55, 0x65, 0xa5, 0xb5, 0xc5 },               /* hmd */
  86 };
  87
  88 /* actual fan speed */
  89 static const u8 FSCHMD_REG_FAN_ACT[5][6] = {
  90         { 0x0e, 0x6b, 0xab },                           /* pos */
  91         { 0x0e, 0x6b, 0xbb },                           /* her */
  92         { 0x6b, 0x6c, 0x0e, 0xab, 0x5c, 0xbb },         /* scy */
  93         { 0x0e, 0x6b, 0xab, 0xbb },                     /* hrc */
  94         { 0x5b, 0x6b, 0xab, 0xbb, 0xcb },               /* hmd */
  95 };
  96
  97 /* fan status registers */
  98 static const u8 FSCHMD_REG_FAN_STATE[5][6] = {
  99         { 0x0d, 0x62, 0xa2 },                           /* pos */
 100         { 0x0d, 0x62, 0xb2 },                           /* her */
 101         { 0x62, 0x61, 0x0d, 0xa2, 0x52, 0xb2 },         /* scy */
 102         { 0x0d, 0x62, 0xa2, 0xb2 },                     /* hrc */
 103         { 0x52, 0x62, 0xa2, 0xb2, 0xc2 },               /* hmd */
 104 };
 105
 106 /* fan ripple / divider registers */
 107 static const u8 FSCHMD_REG_FAN_RIPPLE[5][6] = {
 108         { 0x0f, 0x6f, 0xaf },                           /* pos */
 109         { 0x0f, 0x6f, 0xbf },                           /* her */
 110         { 0x6f, 0x6f, 0x0f, 0xaf, 0x0f, 0xbf },         /* scy */
 111         { 0x0f, 0x6f, 0xaf, 0xbf },                     /* hrc */
 112         { 0x5f, 0x6f, 0xaf, 0xbf, 0xcf },               /* hmd */
 113 };
 114
 115 static const int FSCHMD_NO_FAN_SENSORS[5] = { 3, 3, 6, 4, 5 };
 116
 117 /* Fan status register bitmasks */
 118 #define FSCHMD_FAN_ALARM_MASK           0x04 /* called fault by FSC! */
 119 #define FSCHMD_FAN_NOT_PRESENT_MASK     0x08 /* not documented */
 120
 121
 122 /* actual temperature registers */
 123 static const u8 FSCHMD_REG_TEMP_ACT[5][5] = {
 124         { 0x64, 0x32, 0x35 },                           /* pos */
 125         { 0x64, 0x32, 0x35 },                           /* her */
 126         { 0x64, 0xD0, 0x32, 0x35 },                     /* scy */
 127         { 0x64, 0x32, 0x35 },                           /* hrc */
 128         { 0x70, 0x80, 0x90, 0xd0, 0xe0 },               /* hmd */
 129 };
 130
 131 /* temperature state registers */
 132 static const u8 FSCHMD_REG_TEMP_STATE[5][5] = {
 133         { 0x71, 0x81, 0x91 },                           /* pos */
 134         { 0x71, 0x81, 0x91 },                           /* her */
 135         { 0x71, 0xd1, 0x81, 0x91 },                     /* scy */
 136         { 0x71, 0x81, 0x91 },                           /* hrc */
 137         { 0x71, 0x81, 0x91, 0xd1, 0xe1 },               /* hmd */
 138 };
 139
 140 /* temperature high limit registers, FSC does not document these. Proven to be
 141    there with field testing on the fscher and fschrc, already supported / used
 142    in the fscscy 2.4 driver. FSC has confirmed that the fschmd has registers
 143    at these addresses, but doesn't want to confirm they are the same as with
 144    the fscher?? */
 145 static const u8 FSCHMD_REG_TEMP_LIMIT[5][5] = {
 146         { 0, 0, 0 },                                    /* pos */
 147         { 0x76, 0x86, 0x96 },                           /* her */
 148         { 0x76, 0xd6, 0x86, 0x96 },                     /* scy */
 149         { 0x76, 0x86, 0x96 },                           /* hrc */
 150         { 0x76, 0x86, 0x96, 0xd6, 0xe6 },               /* hmd */
 151 };
 152
 153 /* These were found through experimenting with an fscher, currently they are
 154    not used, but we keep them around for future reference.
 155 static const u8 FSCHER_REG_TEMP_AUTOP1[] =      { 0x73, 0x83, 0x93 };
 156 static const u8 FSCHER_REG_TEMP_AUTOP2[] =      { 0x75, 0x85, 0x95 }; */
 157
 158 static const int FSCHMD_NO_TEMP_SENSORS[5] = { 3, 3, 4, 3, 5 };
 159
 160 /* temp status register bitmasks */
 161 #define FSCHMD_TEMP_WORKING_MASK        0x01
 162 #define FSCHMD_TEMP_ALERT_MASK          0x02
 163 /* there only really is an alarm if the sensor is working and alert == 1 */
 164 #define FSCHMD_TEMP_ALARM_MASK \
 165         (FSCHMD_TEMP_WORKING_MASK | FSCHMD_TEMP_ALERT_MASK)
 166
 167 /* our driver name */
 168 #define FSCHMD_NAME "fschmd"
 169
 170 /*
 171  * Functions declarations
 172  */
 173
 174 static int fschmd_attach_adapter(struct i2c_adapter *adapter);
 175 static int fschmd_detach_client(struct i2c_client *client);
 176 static struct fschmd_data *fschmd_update_device(struct device *dev);
 177
 178 /*
 179  * Driver data (common to all clients)
 180  */
 181
 182 static struct i2c_driver fschmd_driver = {
 183         .driver = {
 184                 .name   = FSCHMD_NAME,
 185         },
 186         .attach_adapter = fschmd_attach_adapter,
 187         .detach_client  = fschmd_detach_client,
 188 };
 189
 190 /*
 191  * Client data (each client gets its own)
 192  */
 193
 194 struct fschmd_data {
 195         struct i2c_client client;
 196         struct device *hwmon_dev;
 197         struct mutex update_lock;
 198         int kind;
 199         char valid; /* zero until following fields are valid */
 200         unsigned long last_updated; /* in jiffies */
 201
 202         /* register values */
 203         u8 global_control;      /* global control register */
 204         u8 volt[3];             /* 12, 5, battery voltage */
 205         u8 temp_act[5];         /* temperature */
 206         u8 temp_status[5];      /* status of sensor */
 207         u8 temp_max[5];         /* high temp limit, notice: undocumented! */
 208         u8 fan_act[6];          /* fans revolutions per second */
 209         u8 fan_status[6];       /* fan status */
 210         u8 fan_min[6];          /* fan min value for rps */
 211         u8 fan_ripple[6];       /* divider for rps */
 212 };
 213
 214 /* Global variables to hold information read from special DMI tables, which are
 215    available on FSC machines with an fscher or later chip. */
 216 static int dmi_mult[3] = { 490, 200, 100 };
 217 static int dmi_offset[3] = { 0, 0, 0 };
 218 static int dmi_vref = -1;
 219
 220
 221 /*
 222  * Sysfs attr show / store functions
 223  */
 224
 225 static ssize_t show_in_value(struct device *dev,
 226         struct device_attribute *devattr, char *buf)
 227 {
 228         const int max_reading[3] = { 14200, 6600, 3300 };
 229         int index = to_sensor_dev_attr(devattr)->index;
 230         struct fschmd_data *data = fschmd_update_device(dev);
 231
 232         /* fscher / fschrc - 1 as data->kind is an array index, not a chips */
 233         if (data->kind == (fscher - 1) || data->kind >= (fschrc - 1))
 234                 return sprintf(buf, "%d\n", (data->volt[index] * dmi_vref *
 235                         dmi_mult[index]) / 255 + dmi_offset[index]);
 236         else
 237                 return sprintf(buf, "%d\n", (data->volt[index] *
 238                         max_reading[index] + 128) / 255);
 239 }
 240
 241
 242 #define TEMP_FROM_REG(val)      (((val) - 128) * 1000)
 243
 244 static ssize_t show_temp_value(struct device *dev,
 245         struct device_attribute *devattr, char *buf)
 246 {
 247         int index = to_sensor_dev_attr(devattr)->index;
 248         struct fschmd_data *data = fschmd_update_device(dev);
 249
 250         return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_act[index]));
 251 }
 252
 253 static ssize_t show_temp_max(struct device *dev,
 254         struct device_attribute *devattr, char *buf)
 255 {
 256         int index = to_sensor_dev_attr(devattr)->index;
 257         struct fschmd_data *data = fschmd_update_device(dev);
 258
 259         return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_max[index]));
 260 }
 261
 262 static ssize_t store_temp_max(struct device *dev, struct device_attribute
 263         *devattr, const char *buf, size_t count)
 264 {
 265         int index = to_sensor_dev_attr(devattr)->index;
 266         struct fschmd_data *data = dev_get_drvdata(dev);
 267         long v = simple_strtol(buf, NULL, 10) / 1000;
 268
 269         v = SENSORS_LIMIT(v, -128, 127) + 128;
 270
 271         mutex_lock(&data->update_lock);
 272         i2c_smbus_write_byte_data(&data->client,
 273                 FSCHMD_REG_TEMP_LIMIT[data->kind][index], v);
 274         data->temp_max[index] = v;
 275         mutex_unlock(&data->update_lock);
 276
 277         return count;
 278 }
 279
 280 static ssize_t show_temp_fault(struct device *dev,
 281         struct device_attribute *devattr, char *buf)
 282 {
 283         int index = to_sensor_dev_attr(devattr)->index;
 284         struct fschmd_data *data = fschmd_update_device(dev);
 285
 286         /* bit 0 set means sensor working ok, so no fault! */
 287         if (data->temp_status[index] & FSCHMD_TEMP_WORKING_MASK)
 288                 return sprintf(buf, "0\n");
 289         else
 290                 return sprintf(buf, "1\n");
 291 }
 292
 293 static ssize_t show_temp_alarm(struct device *dev,
 294         struct device_attribute *devattr, char *buf)
 295 {
 296         int index = to_sensor_dev_attr(devattr)->index;
 297         struct fschmd_data *data = fschmd_update_device(dev);
 298
 299         if ((data->temp_status[index] & FSCHMD_TEMP_ALARM_MASK) ==
 300                         FSCHMD_TEMP_ALARM_MASK)
 301                 return sprintf(buf, "1\n");
 302         else
 303                 return sprintf(buf, "0\n");
 304 }
 305
 306
 307 #define RPM_FROM_REG(val)       ((val) * 60)
 308
 309 static ssize_t show_fan_value(struct device *dev,
 310         struct device_attribute *devattr, char *buf)
 311 {
 312         int index = to_sensor_dev_attr(devattr)->index;
 313         struct fschmd_data *data = fschmd_update_device(dev);
 314
 315         return sprintf(buf, "%u\n", RPM_FROM_REG(data->fan_act[index]));
 316 }
 317
 318 static ssize_t show_fan_div(struct device *dev,
 319         struct device_attribute *devattr, char *buf)
 320 {
 321         int index = to_sensor_dev_attr(devattr)->index;
 322         struct fschmd_data *data = fschmd_update_device(dev);
 323
 324         /* bits 2..7 reserved => mask with 3 */
 325         return sprintf(buf, "%d\n", 1 << (data->fan_ripple[index] & 3));
 326 }
 327
 328 static ssize_t store_fan_div(struct device *dev, struct device_attribute
 329         *devattr, const char *buf, size_t count)
 330 {
 331         u8 reg;
 332         int index = to_sensor_dev_attr(devattr)->index;
 333         struct fschmd_data *data = dev_get_drvdata(dev);
 334         /* supported values: 2, 4, 8 */
 335         unsigned long v = simple_strtoul(buf, NULL, 10);
 336
 337         switch (v) {
 338         case 2: v = 1; break;
 339         case 4: v = 2; break;
 340         case 8: v = 3; break;
 341         default:
 342                 dev_err(dev, "fan_div value %lu not supported. "
 343                         "Choose one of 2, 4 or 8!\n", v);
 344                 return -EINVAL;
 345         }
 346
 347         mutex_lock(&data->update_lock);
 348
 349         reg = i2c_smbus_read_byte_data(&data->client,
 350                 FSCHMD_REG_FAN_RIPPLE[data->kind][index]);
 351
 352         /* bits 2..7 reserved => mask with 0x03 */
 353         reg &= ~0x03;
 354         reg |= v;
 355
 356         i2c_smbus_write_byte_data(&data->client,
 357                 FSCHMD_REG_FAN_RIPPLE[data->kind][index], reg);
 358
 359         data->fan_ripple[index] = reg;
 360
 361         mutex_unlock(&data->update_lock);
 362
 363         return count;
 364 }
 365
 366 static ssize_t show_fan_alarm(struct device *dev,
 367         struct device_attribute *devattr, char *buf)
 368 {
 369         int index = to_sensor_dev_attr(devattr)->index;
 370         struct fschmd_data *data = fschmd_update_device(dev);
 371
 372         if (data->fan_status[index] & FSCHMD_FAN_ALARM_MASK)
 373                 return sprintf(buf, "1\n");
 374         else
 375                 return sprintf(buf, "0\n");
 376 }
 377
 378 static ssize_t show_fan_fault(struct device *dev,
 379         struct device_attribute *devattr, char *buf)
 380 {
 381         int index = to_sensor_dev_attr(devattr)->index;
 382         struct fschmd_data *data = fschmd_update_device(dev);
 383
 384         if (data->fan_status[index] & FSCHMD_FAN_NOT_PRESENT_MASK)
 385                 return sprintf(buf, "1\n");
 386         else
 387                 return sprintf(buf, "0\n");
 388 }
 389
 390
 391 static ssize_t show_pwm_auto_point1_pwm(struct device *dev,
 392         struct device_attribute *devattr, char *buf)
 393 {
 394         int index = to_sensor_dev_attr(devattr)->index;
 395         int val = fschmd_update_device(dev)->fan_min[index];
 396
 397         /* 0 = allow turning off, 1-255 = 50-100% */
 398         if (val)
 399                 val = val / 2 + 128;
 400
 401         return sprintf(buf, "%d\n", val);
 402 }
 403
 404 static ssize_t store_pwm_auto_point1_pwm(struct device *dev,
 405         struct device_attribute *devattr, const char *buf, size_t count)
 406 {
 407         int index = to_sensor_dev_attr(devattr)->index;
 408         struct fschmd_data *data = dev_get_drvdata(dev);
 409         unsigned long v = simple_strtoul(buf, NULL, 10);
 410
 411         /* register: 0 = allow turning off, 1-255 = 50-100% */
 412         if (v) {
 413                 v = SENSORS_LIMIT(v, 128, 255);
 414                 v = (v - 128) * 2 + 1;
 415         }
 416
 417         mutex_lock(&data->update_lock);
 418
 419         i2c_smbus_write_byte_data(&data->client,
 420                 FSCHMD_REG_FAN_MIN[data->kind][index], v);
 421         data->fan_min[index] = v;
 422
 423         mutex_unlock(&data->update_lock);
 424
 425         return count;
 426 }
 427
 428
 429 /* The FSC hwmon family has the ability to force an attached alert led to flash
 430    from software, we export this as an alert_led sysfs attr */
 431 static ssize_t show_alert_led(struct device *dev,
 432         struct device_attribute *devattr, char *buf)
 433 {
 434         struct fschmd_data *data = fschmd_update_device(dev);
 435
 436         if (data->global_control & FSCHMD_CONTROL_ALERT_LED_MASK)
 437                 return sprintf(buf, "1\n");
 438         else
 439                 return sprintf(buf, "0\n");
 440 }
 441
 442 static ssize_t store_alert_led(struct device *dev,
 443         struct device_attribute *devattr, const char *buf, size_t count)
 444 {
 445         u8 reg;
 446         struct fschmd_data *data = dev_get_drvdata(dev);
 447         unsigned long v = simple_strtoul(buf, NULL, 10);
 448
 449         mutex_lock(&data->update_lock);
 450
 451         reg = i2c_smbus_read_byte_data(&data->client, FSCHMD_REG_CONTROL);
 452
 453         if (v)
 454                 reg |= FSCHMD_CONTROL_ALERT_LED_MASK;
 455         else
 456                 reg &= ~FSCHMD_CONTROL_ALERT_LED_MASK;
 457
 458         i2c_smbus_write_byte_data(&data->client, FSCHMD_REG_CONTROL, reg);
 459
 460         data->global_control = reg;
 461
 462         mutex_unlock(&data->update_lock);
 463
 464         return count;
 465 }
 466
 467 static struct sensor_device_attribute fschmd_attr[] = {
 468         SENSOR_ATTR(in0_input, 0444, show_in_value, NULL, 0),
 469         SENSOR_ATTR(in1_input, 0444, show_in_value, NULL, 1),
 470         SENSOR_ATTR(in2_input, 0444, show_in_value, NULL, 2),
 471         SENSOR_ATTR(alert_led, 0644, show_alert_led, store_alert_led, 0),
 472 };
 473
 474 static struct sensor_device_attribute fschmd_temp_attr[] = {
 475         SENSOR_ATTR(temp1_input, 0444, show_temp_value, NULL, 0),
 476         SENSOR_ATTR(temp1_max,   0644, show_temp_max, store_temp_max, 0),
 477         SENSOR_ATTR(temp1_fault, 0444, show_temp_fault, NULL, 0),
 478         SENSOR_ATTR(temp1_alarm, 0444, show_temp_alarm, NULL, 0),
 479         SENSOR_ATTR(temp2_input, 0444, show_temp_value, NULL, 1),
 480         SENSOR_ATTR(temp2_max,   0644, show_temp_max, store_temp_max, 1),
 481         SENSOR_ATTR(temp2_fault, 0444, show_temp_fault, NULL, 1),
 482         SENSOR_ATTR(temp2_alarm, 0444, show_temp_alarm, NULL, 1),
 483         SENSOR_ATTR(temp3_input, 0444, show_temp_value, NULL, 2),
 484         SENSOR_ATTR(temp3_max,   0644, show_temp_max, store_temp_max, 2),
 485         SENSOR_ATTR(temp3_fault, 0444, show_temp_fault, NULL, 2),
 486         SENSOR_ATTR(temp3_alarm, 0444, show_temp_alarm, NULL, 2),
 487         SENSOR_ATTR(temp4_input, 0444, show_temp_value, NULL, 3),
 488         SENSOR_ATTR(temp4_max,   0644, show_temp_max, store_temp_max, 3),
 489         SENSOR_ATTR(temp4_fault, 0444, show_temp_fault, NULL, 3),
 490         SENSOR_ATTR(temp4_alarm, 0444, show_temp_alarm, NULL, 3),
 491         SENSOR_ATTR(temp5_input, 0444, show_temp_value, NULL, 4),
 492         SENSOR_ATTR(temp5_max,   0644, show_temp_max, store_temp_max, 4),
 493         SENSOR_ATTR(temp5_fault, 0444, show_temp_fault, NULL, 4),
 494         SENSOR_ATTR(temp5_alarm, 0444, show_temp_alarm, NULL, 4),
 495 };
 496
 497 static struct sensor_device_attribute fschmd_fan_attr[] = {
 498         SENSOR_ATTR(fan1_input, 0444, show_fan_value, NULL, 0),
 499         SENSOR_ATTR(fan1_div,   0644, show_fan_div, store_fan_div, 0),
 500         SENSOR_ATTR(fan1_alarm, 0444, show_fan_alarm, NULL, 0),
 501         SENSOR_ATTR(fan1_fault, 0444, show_fan_fault, NULL, 0),
 502         SENSOR_ATTR(pwm1_auto_point1_pwm, 0644, show_pwm_auto_point1_pwm,
 503                 store_pwm_auto_point1_pwm, 0),
 504         SENSOR_ATTR(fan2_input, 0444, show_fan_value, NULL, 1),
 505         SENSOR_ATTR(fan2_div,   0644, show_fan_div, store_fan_div, 1),
 506         SENSOR_ATTR(fan2_alarm, 0444, show_fan_alarm, NULL, 1),
 507         SENSOR_ATTR(fan2_fault, 0444, show_fan_fault, NULL, 1),
 508         SENSOR_ATTR(pwm2_auto_point1_pwm, 0644, show_pwm_auto_point1_pwm,
 509                 store_pwm_auto_point1_pwm, 1),
 510         SENSOR_ATTR(fan3_input, 0444, show_fan_value, NULL, 2),
 511         SENSOR_ATTR(fan3_div,   0644, show_fan_div, store_fan_div, 2),
 512         SENSOR_ATTR(fan3_alarm, 0444, show_fan_alarm, NULL, 2),
 513         SENSOR_ATTR(fan3_fault, 0444, show_fan_fault, NULL, 2),
 514         SENSOR_ATTR(pwm3_auto_point1_pwm, 0644, show_pwm_auto_point1_pwm,
 515                 store_pwm_auto_point1_pwm, 2),
 516         SENSOR_ATTR(fan4_input, 0444, show_fan_value, NULL, 3),
 517         SENSOR_ATTR(fan4_div,   0644, show_fan_div, store_fan_div, 3),
 518         SENSOR_ATTR(fan4_alarm, 0444, show_fan_alarm, NULL, 3),
 519         SENSOR_ATTR(fan4_fault, 0444, show_fan_fault, NULL, 3),
 520         SENSOR_ATTR(pwm4_auto_point1_pwm, 0644, show_pwm_auto_point1_pwm,
 521                 store_pwm_auto_point1_pwm, 3),
 522         SENSOR_ATTR(fan5_input, 0444, show_fan_value, NULL, 4),
 523         SENSOR_ATTR(fan5_div,   0644, show_fan_div, store_fan_div, 4),
 524         SENSOR_ATTR(fan5_alarm, 0444, show_fan_alarm, NULL, 4),
 525         SENSOR_ATTR(fan5_fault, 0444, show_fan_fault, NULL, 4),
 526         SENSOR_ATTR(pwm5_auto_point1_pwm, 0644, show_pwm_auto_point1_pwm,
 527                 store_pwm_auto_point1_pwm, 4),
 528         SENSOR_ATTR(fan6_input, 0444, show_fan_value, NULL, 5),
 529         SENSOR_ATTR(fan6_div,   0644, show_fan_div, store_fan_div, 5),
 530         SENSOR_ATTR(fan6_alarm, 0444, show_fan_alarm, NULL, 5),
 531         SENSOR_ATTR(fan6_fault, 0444, show_fan_fault, NULL, 5),
 532         SENSOR_ATTR(pwm6_auto_point1_pwm, 0644, show_pwm_auto_point1_pwm,
 533                 store_pwm_auto_point1_pwm, 5),
 534 };
 535
 536
 537 /*
 538  * Real code
 539  */
 540
 541 /* DMI decode routine to read voltage scaling factors from special DMI tables,
 542    which are available on FSC machines with an fscher or later chip. */
 543 static void fschmd_dmi_decode(const struct dmi_header *header)
 544 {
 545         int i, mult[3] = { 0 }, offset[3] = { 0 }, vref = 0, found = 0;
 546
 547         /* dmi code ugliness, we get passed the address of the contents of
 548            a complete DMI record, but in the form of a dmi_header pointer, in
 549            reality this address holds header->length bytes of which the header
 550            are the first 4 bytes */
 551         u8 *dmi_data = (u8 *)header;
 552
 553         /* We are looking for OEM-specific type 185 */
 554         if (header->type != 185)
 555                 return;
 556
 557         /* we are looking for what Siemens calls "subtype" 19, the subtype
 558            is stored in byte 5 of the dmi block */
 559         if (header->length < 5 || dmi_data[4] != 19)
 560                 return;
 561
 562         /* After the subtype comes 1 unknown byte and then blocks of 5 bytes,
 563            consisting of what Siemens calls an "Entity" number, followed by
 564            2 16-bit words in LSB first order */
 565         for (i = 6; (i + 4) < header->length; i += 5) {
 566                 /* entity 1 - 3: voltage multiplier and offset */
 567                 if (dmi_data[i] >= 1 && dmi_data[i] <= 3) {
 568                         /* Our in sensors order and the DMI order differ */
 569                         const int shuffle[3] = { 1, 0, 2 };
 570                         int in = shuffle[dmi_data[i] - 1];
 571
 572                         /* Check for twice the same entity */
 573                         if (found & (1 << in))
 574                                 return;
 575
 576                         mult[in] = dmi_data[i + 1] | (dmi_data[i + 2] << 8);
 577                         offset[in] = dmi_data[i + 3] | (dmi_data[i + 4] << 8);
 578
 579                         found |= 1 << in;
 580                 }
 581
 582                 /* entity 7: reference voltage */
 583                 if (dmi_data[i] == 7) {
 584                         /* Check for twice the same entity */
 585                         if (found & 0x08)
 586                                 return;
 587
 588                         vref = dmi_data[i + 1] | (dmi_data[i + 2] << 8);
 589
 590                         found |= 0x08;
 591                 }
 592         }
 593
 594         if (found == 0x0F) {
 595                 for (i = 0; i < 3; i++) {
 596                         dmi_mult[i] = mult[i] * 10;
 597                         dmi_offset[i] = offset[i] * 10;
 598                 }
 599                 dmi_vref = vref;
 600         }
 601 }
 602
 603 static int fschmd_detect(struct i2c_adapter *adapter, int address, int kind)
 604 {
 605         struct i2c_client *client;
 606         struct fschmd_data *data;
 607         u8 revision;
 608         const char * const names[5] = { "Poseidon", "Hermes", "Scylla",
 609                                         "Heracles", "Heimdall" };
 610         const char * const client_names[5] = { "fscpos", "fscher", "fscscy",
 611                                                 "fschrc", "fschmd" };
 612         int i, err = 0;
 613
 614         if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
 615                 return 0;
 616
 617         /* OK. For now, we presume we have a valid client. We now create the
 618          * client structure, even though we cannot fill it completely yet.
 619          * But it allows us to access i2c_smbus_read_byte_data. */
 620         if (!(data = kzalloc(sizeof(struct fschmd_data), GFP_KERNEL)))
 621                 return -ENOMEM;
 622
 623         client = &data->client;
 624         i2c_set_clientdata(client, data);
 625         client->addr = address;
 626         client->adapter = adapter;
 627         client->driver = &fschmd_driver;
 628         mutex_init(&data->update_lock);
 629
 630         /* Detect & Identify the chip */
 631         if (kind <= 0) {
 632                 char id[4];
 633
 634                 id[0] = i2c_smbus_read_byte_data(client,
 635                                 FSCHMD_REG_IDENT_0);
 636                 id[1] = i2c_smbus_read_byte_data(client,
 637                                 FSCHMD_REG_IDENT_1);
 638                 id[2] = i2c_smbus_read_byte_data(client,
 639                                 FSCHMD_REG_IDENT_2);
 640                 id[3] = '\0';
 641
 642                 if (!strcmp(id, "PEG"))
 643                         kind = fscpos;
 644                 else if (!strcmp(id, "HER"))
 645                         kind = fscher;
 646                 else if (!strcmp(id, "SCY"))
 647                         kind = fscscy;
 648                 else if (!strcmp(id, "HRC"))
 649                         kind = fschrc;
 650                 else if (!strcmp(id, "HMD"))
 651                         kind = fschmd;
 652                 else
 653                         goto exit_free;
 654         }
 655
 656         if (kind == fscpos) {
 657                 /* The Poseidon has hardwired temp limits, fill these
 658                    in for the alarm resetting code */
 659                 data->temp_max[0] = 70 + 128;
 660                 data->temp_max[1] = 50 + 128;
 661                 data->temp_max[2] = 50 + 128;
 662         }
 663
 664         /* Read the special DMI table for fscher and newer chips */
 665         if (kind == fscher || kind >= fschrc) {
 666                 dmi_walk(fschmd_dmi_decode);
 667                 if (dmi_vref == -1) {
 668                         printk(KERN_WARNING FSCHMD_NAME
 669                                 ": Couldn't get voltage scaling factors from "
 670                                 "BIOS DMI table, using builtin defaults\n");
 671                         dmi_vref = 33;
 672                 }
 673         }
 674
 675         /* i2c kind goes from 1-5, we want from 0-4 to address arrays */
 676         data->kind = kind - 1;
 677         strlcpy(client->name, client_names[data->kind], I2C_NAME_SIZE);
 678
 679         /* Tell the I2C layer a new client has arrived */
 680         if ((err = i2c_attach_client(client)))
 681                 goto exit_free;
 682
 683         for (i = 0; i < ARRAY_SIZE(fschmd_attr); i++) {
 684                 err = device_create_file(&client->dev,
 685                                         &fschmd_attr[i].dev_attr);
 686                 if (err)
 687                         goto exit_detach;
 688         }
 689
 690         for (i = 0; i < (FSCHMD_NO_TEMP_SENSORS[data->kind] * 4); i++) {
 691                 /* Poseidon doesn't have TEMP_LIMIT registers */
 692                 if (kind == fscpos && fschmd_temp_attr[i].dev_attr.show ==
 693                                 show_temp_max)
 694                         continue;
 695
 696                 err = device_create_file(&client->dev,
 697                                         &fschmd_temp_attr[i].dev_attr);
 698                 if (err)
 699                         goto exit_detach;
 700         }
 701
 702         for (i = 0; i < (FSCHMD_NO_FAN_SENSORS[data->kind] * 5); i++) {
 703                 /* Poseidon doesn't have a FAN_MIN register for its 3rd fan */
 704                 if (kind == fscpos &&
 705                                 !strcmp(fschmd_fan_attr[i].dev_attr.attr.name,
 706                                         "pwm3_auto_point1_pwm"))
 707                         continue;
 708
 709                 err = device_create_file(&client->dev,
 710                                         &fschmd_fan_attr[i].dev_attr);
 711                 if (err)
 712                         goto exit_detach;
 713         }
 714
 715         data->hwmon_dev = hwmon_device_register(&client->dev);
 716         if (IS_ERR(data->hwmon_dev)) {
 717                 err = PTR_ERR(data->hwmon_dev);
 718                 data->hwmon_dev = NULL;
 719                 goto exit_detach;
 720         }
 721
 722         revision = i2c_smbus_read_byte_data(client, FSCHMD_REG_REVISION);
 723         printk(KERN_INFO FSCHMD_NAME ": Detected FSC %s chip, revision: %d\n",
 724                 names[data->kind], (int) revision);
 725
 726         return 0;
 727
 728 exit_detach:
 729         fschmd_detach_client(client); /* will also free data for us */
 730         return err;
 731
 732 exit_free:
 733         kfree(data);
 734         return err;
 735 }
 736
 737 static int fschmd_attach_adapter(struct i2c_adapter *adapter)
 738 {
 739         if (!(adapter->class & I2C_CLASS_HWMON))
 740                 return 0;
 741         return i2c_probe(adapter, &addr_data, fschmd_detect);
 742 }
 743
 744 static int fschmd_detach_client(struct i2c_client *client)
 745 {
 746         struct fschmd_data *data = i2c_get_clientdata(client);
 747         int i, err;
 748
 749         /* Check if registered in case we're called from fschmd_detect
 750            to cleanup after an error */
 751         if (data->hwmon_dev)
 752                 hwmon_device_unregister(data->hwmon_dev);
 753
 754         for (i = 0; i < ARRAY_SIZE(fschmd_attr); i++)
 755                 device_remove_file(&client->dev, &fschmd_attr[i].dev_attr);
 756         for (i = 0; i < (FSCHMD_NO_TEMP_SENSORS[data->kind] * 4); i++)
 757                 device_remove_file(&client->dev,
 758                                         &fschmd_temp_attr[i].dev_attr);
 759         for (i = 0; i < (FSCHMD_NO_FAN_SENSORS[data->kind] * 5); i++)
 760                 device_remove_file(&client->dev,
 761                                         &fschmd_fan_attr[i].dev_attr);
 762
 763         if ((err = i2c_detach_client(client)))
 764                 return err;
 765
 766         kfree(data);
 767         return 0;
 768 }
 769
 770 static struct fschmd_data *fschmd_update_device(struct device *dev)
 771 {
 772         struct i2c_client *client = to_i2c_client(dev);
 773         struct fschmd_data *data = i2c_get_clientdata(client);
 774         int i;
 775
 776         mutex_lock(&data->update_lock);
 777
 778         if (time_after(jiffies, data->last_updated + 2 * HZ) || !data->valid) {
 779
 780                 for (i = 0; i < FSCHMD_NO_TEMP_SENSORS[data->kind]; i++) {
 781                         data->temp_act[i] = i2c_smbus_read_byte_data(client,
 782                                         FSCHMD_REG_TEMP_ACT[data->kind][i]);
 783                         data->temp_status[i] = i2c_smbus_read_byte_data(client,
 784                                         FSCHMD_REG_TEMP_STATE[data->kind][i]);
 785
 786                         /* The fscpos doesn't have TEMP_LIMIT registers */
 787                         if (FSCHMD_REG_TEMP_LIMIT[data->kind][i])
 788                                 data->temp_max[i] = i2c_smbus_read_byte_data(
 789                                         client,
 790                                         FSCHMD_REG_TEMP_LIMIT[data->kind][i]);
 791
 792                         /* reset alarm if the alarm condition is gone,
 793                            the chip doesn't do this itself */
 794                         if ((data->temp_status[i] & FSCHMD_TEMP_ALARM_MASK) ==
 795                                         FSCHMD_TEMP_ALARM_MASK &&
 796                                         data->temp_act[i] < data->temp_max[i])
 797                                 i2c_smbus_write_byte_data(client,
 798                                         FSCHMD_REG_TEMP_STATE[data->kind][i],
 799                                         FSCHMD_TEMP_ALERT_MASK);
 800                 }
 801
 802                 for (i = 0; i < FSCHMD_NO_FAN_SENSORS[data->kind]; i++) {
 803                         data->fan_act[i] = i2c_smbus_read_byte_data(client,
 804                                         FSCHMD_REG_FAN_ACT[data->kind][i]);
 805                         data->fan_status[i] = i2c_smbus_read_byte_data(client,
 806                                         FSCHMD_REG_FAN_STATE[data->kind][i]);
 807                         data->fan_ripple[i] = i2c_smbus_read_byte_data(client,
 808                                         FSCHMD_REG_FAN_RIPPLE[data->kind][i]);
 809
 810                         /* The fscpos third fan doesn't have a fan_min */
 811                         if (FSCHMD_REG_FAN_MIN[data->kind][i])
 812                                 data->fan_min[i] = i2c_smbus_read_byte_data(
 813                                         client,
 814                                         FSCHMD_REG_FAN_MIN[data->kind][i]);
 815
 816                         /* reset fan status if speed is back to > 0 */
 817                         if ((data->fan_status[i] & FSCHMD_FAN_ALARM_MASK) &&
 818                                         data->fan_act[i])
 819                                 i2c_smbus_write_byte_data(client,
 820                                         FSCHMD_REG_FAN_STATE[data->kind][i],
 821                                         FSCHMD_FAN_ALARM_MASK);
 822                 }
 823
 824                 for (i = 0; i < 3; i++)
 825                         data->volt[i] = i2c_smbus_read_byte_data(client,
 826                                                 FSCHMD_REG_VOLT[i]);
 827
 828                 data->global_control = i2c_smbus_read_byte_data(client,
 829                                                 FSCHMD_REG_CONTROL);
 830
 831                 /* To be implemented in the future
 832                 data->watchdog[0] = i2c_smbus_read_byte_data(client,
 833                                                 FSCHMD_REG_WDOG_PRESET);
 834                 data->watchdog[1] = i2c_smbus_read_byte_data(client,
 835                                                 FSCHMD_REG_WDOG_STATE);
 836                 data->watchdog[2] = i2c_smbus_read_byte_data(client,
 837                                                 FSCHMD_REG_WDOG_CONTROL); */
 838
 839                 data->last_updated = jiffies;
 840                 data->valid = 1;
 841         }
 842
 843         mutex_unlock(&data->update_lock);
 844
 845         return data;
 846 }
 847
 848 static int __init fschmd_init(void)
 849 {
 850         return i2c_add_driver(&fschmd_driver);
 851 }
 852
 853 static void __exit fschmd_exit(void)
 854 {
 855         i2c_del_driver(&fschmd_driver);
 856 }
 857
 858 MODULE_AUTHOR("Hans de Goede <j.w.r.degoede@hhs.nl>");
 859 MODULE_DESCRIPTION("FSC Poseidon, Hermes, Scylla, Heracles and "
 860                         "Heimdall driver");
 861 MODULE_LICENSE("GPL");
 862
 863 module_init(fschmd_init);
 864 module_exit(fschmd_exit);