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 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); 865