1 /* 2 * Support for the FTS Systemmonitoring Chip "Teutates" 3 * 4 * Copyright (C) 2016 Fujitsu Technology Solutions GmbH, 5 * Thilo Cestonaro <thilo.cestonaro@ts.fujitsu.com> 6 * 7 * This program is free software; you can redistribute it and/or modify 8 * it under the terms of the GNU General Public License as published by 9 * the Free Software Foundation; either version 2 of the License, or 10 * (at your option) any later version. 11 * 12 * This program is distributed in the hope that it will be useful, 13 * but WITHOUT ANY WARRANTY; without even the implied warranty of 14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 * GNU General Public License for more details. 16 * 17 */ 18 #include <linux/err.h> 19 #include <linux/fs.h> 20 #include <linux/hwmon.h> 21 #include <linux/hwmon-sysfs.h> 22 #include <linux/i2c.h> 23 #include <linux/init.h> 24 #include <linux/jiffies.h> 25 #include <linux/module.h> 26 #include <linux/mutex.h> 27 #include <linux/slab.h> 28 #include <linux/sysfs.h> 29 #include <linux/uaccess.h> 30 #include <linux/watchdog.h> 31 32 #define FTS_DEVICE_ID_REG 0x0000 33 #define FTS_DEVICE_REVISION_REG 0x0001 34 #define FTS_DEVICE_STATUS_REG 0x0004 35 #define FTS_SATELLITE_STATUS_REG 0x0005 36 #define FTS_EVENT_STATUS_REG 0x0006 37 #define FTS_GLOBAL_CONTROL_REG 0x0007 38 39 #define FTS_DEVICE_DETECT_REG_1 0x0C 40 #define FTS_DEVICE_DETECT_REG_2 0x0D 41 #define FTS_DEVICE_DETECT_REG_3 0x0E 42 43 #define FTS_SENSOR_EVENT_REG 0x0010 44 45 #define FTS_FAN_EVENT_REG 0x0014 46 #define FTS_FAN_PRESENT_REG 0x0015 47 48 #define FTS_POWER_ON_TIME_COUNTER_A 0x007A 49 #define FTS_POWER_ON_TIME_COUNTER_B 0x007B 50 #define FTS_POWER_ON_TIME_COUNTER_C 0x007C 51 52 #define FTS_PAGE_SELECT_REG 0x007F 53 54 #define FTS_WATCHDOG_TIME_PRESET 0x000B 55 #define FTS_WATCHDOG_CONTROL 0x5081 56 57 #define FTS_NO_FAN_SENSORS 0x08 58 #define FTS_NO_TEMP_SENSORS 0x10 59 #define FTS_NO_VOLT_SENSORS 0x04 60 61 static const unsigned short normal_i2c[] = { 0x73, I2C_CLIENT_END }; 62 63 static const struct i2c_device_id fts_id[] = { 64 { "ftsteutates", 0 }, 65 { } 66 }; 67 MODULE_DEVICE_TABLE(i2c, fts_id); 68 69 enum WATCHDOG_RESOLUTION { 70 seconds = 1, 71 minutes = 60 72 }; 73 74 struct fts_data { 75 struct i2c_client *client; 76 /* update sensor data lock */ 77 struct mutex update_lock; 78 /* read/write register lock */ 79 struct mutex access_lock; 80 unsigned long last_updated; /* in jiffies */ 81 struct watchdog_device wdd; 82 enum WATCHDOG_RESOLUTION resolution; 83 bool valid; /* false until following fields are valid */ 84 85 u8 volt[FTS_NO_VOLT_SENSORS]; 86 87 u8 temp_input[FTS_NO_TEMP_SENSORS]; 88 u8 temp_alarm; 89 90 u8 fan_present; 91 u8 fan_input[FTS_NO_FAN_SENSORS]; /* in rps */ 92 u8 fan_source[FTS_NO_FAN_SENSORS]; 93 u8 fan_alarm; 94 }; 95 96 #define FTS_REG_FAN_INPUT(idx) ((idx) + 0x20) 97 #define FTS_REG_FAN_SOURCE(idx) ((idx) + 0x30) 98 #define FTS_REG_FAN_CONTROL(idx) (((idx) << 16) + 0x4881) 99 100 #define FTS_REG_TEMP_INPUT(idx) ((idx) + 0x40) 101 #define FTS_REG_TEMP_CONTROL(idx) (((idx) << 16) + 0x0681) 102 103 #define FTS_REG_VOLT(idx) ((idx) + 0x18) 104 105 /*****************************************************************************/ 106 /* I2C Helper functions */ 107 /*****************************************************************************/ 108 static int fts_read_byte(struct i2c_client *client, unsigned short reg) 109 { 110 int ret; 111 unsigned char page = reg >> 8; 112 struct fts_data *data = dev_get_drvdata(&client->dev); 113 114 mutex_lock(&data->access_lock); 115 116 dev_dbg(&client->dev, "page select - page: 0x%.02x\n", page); 117 ret = i2c_smbus_write_byte_data(client, FTS_PAGE_SELECT_REG, page); 118 if (ret < 0) 119 goto error; 120 121 reg &= 0xFF; 122 ret = i2c_smbus_read_byte_data(client, reg); 123 dev_dbg(&client->dev, "read - reg: 0x%.02x: val: 0x%.02x\n", reg, ret); 124 125 error: 126 mutex_unlock(&data->access_lock); 127 return ret; 128 } 129 130 static int fts_write_byte(struct i2c_client *client, unsigned short reg, 131 unsigned char value) 132 { 133 int ret; 134 unsigned char page = reg >> 8; 135 struct fts_data *data = dev_get_drvdata(&client->dev); 136 137 mutex_lock(&data->access_lock); 138 139 dev_dbg(&client->dev, "page select - page: 0x%.02x\n", page); 140 ret = i2c_smbus_write_byte_data(client, FTS_PAGE_SELECT_REG, page); 141 if (ret < 0) 142 goto error; 143 144 reg &= 0xFF; 145 dev_dbg(&client->dev, 146 "write - reg: 0x%.02x: val: 0x%.02x\n", reg, value); 147 ret = i2c_smbus_write_byte_data(client, reg, value); 148 149 error: 150 mutex_unlock(&data->access_lock); 151 return ret; 152 } 153 154 /*****************************************************************************/ 155 /* Data Updater Helper function */ 156 /*****************************************************************************/ 157 static int fts_update_device(struct fts_data *data) 158 { 159 int i; 160 int err = 0; 161 162 mutex_lock(&data->update_lock); 163 if (!time_after(jiffies, data->last_updated + 2 * HZ) && data->valid) 164 goto exit; 165 166 err = fts_read_byte(data->client, FTS_DEVICE_STATUS_REG); 167 if (err < 0) 168 goto exit; 169 170 data->valid = !!(err & 0x02); /* Data not ready yet */ 171 if (unlikely(!data->valid)) { 172 err = -EAGAIN; 173 goto exit; 174 } 175 176 err = fts_read_byte(data->client, FTS_FAN_PRESENT_REG); 177 if (err < 0) 178 goto exit; 179 data->fan_present = err; 180 181 err = fts_read_byte(data->client, FTS_FAN_EVENT_REG); 182 if (err < 0) 183 goto exit; 184 data->fan_alarm = err; 185 186 for (i = 0; i < FTS_NO_FAN_SENSORS; i++) { 187 if (data->fan_present & BIT(i)) { 188 err = fts_read_byte(data->client, FTS_REG_FAN_INPUT(i)); 189 if (err < 0) 190 goto exit; 191 data->fan_input[i] = err; 192 193 err = fts_read_byte(data->client, 194 FTS_REG_FAN_SOURCE(i)); 195 if (err < 0) 196 goto exit; 197 data->fan_source[i] = err; 198 } else { 199 data->fan_input[i] = 0; 200 data->fan_source[i] = 0; 201 } 202 } 203 204 err = fts_read_byte(data->client, FTS_SENSOR_EVENT_REG); 205 if (err < 0) 206 goto exit; 207 data->temp_alarm = err; 208 209 for (i = 0; i < FTS_NO_TEMP_SENSORS; i++) { 210 err = fts_read_byte(data->client, FTS_REG_TEMP_INPUT(i)); 211 if (err < 0) 212 goto exit; 213 data->temp_input[i] = err; 214 } 215 216 for (i = 0; i < FTS_NO_VOLT_SENSORS; i++) { 217 err = fts_read_byte(data->client, FTS_REG_VOLT(i)); 218 if (err < 0) 219 goto exit; 220 data->volt[i] = err; 221 } 222 data->last_updated = jiffies; 223 err = 0; 224 exit: 225 mutex_unlock(&data->update_lock); 226 return err; 227 } 228 229 /*****************************************************************************/ 230 /* Watchdog functions */ 231 /*****************************************************************************/ 232 static int fts_wd_set_resolution(struct fts_data *data, 233 enum WATCHDOG_RESOLUTION resolution) 234 { 235 int ret; 236 237 if (data->resolution == resolution) 238 return 0; 239 240 ret = fts_read_byte(data->client, FTS_WATCHDOG_CONTROL); 241 if (ret < 0) 242 return ret; 243 244 if ((resolution == seconds && ret & BIT(1)) || 245 (resolution == minutes && (ret & BIT(1)) == 0)) { 246 data->resolution = resolution; 247 return 0; 248 } 249 250 if (resolution == seconds) 251 ret |= BIT(1); 252 else 253 ret &= ~BIT(1); 254 255 ret = fts_write_byte(data->client, FTS_WATCHDOG_CONTROL, ret); 256 if (ret < 0) 257 return ret; 258 259 data->resolution = resolution; 260 return ret; 261 } 262 263 static int fts_wd_set_timeout(struct watchdog_device *wdd, unsigned int timeout) 264 { 265 struct fts_data *data; 266 enum WATCHDOG_RESOLUTION resolution = seconds; 267 int ret; 268 269 data = watchdog_get_drvdata(wdd); 270 /* switch watchdog resolution to minutes if timeout does not fit 271 * into a byte 272 */ 273 if (timeout > 0xFF) { 274 timeout = DIV_ROUND_UP(timeout, 60) * 60; 275 resolution = minutes; 276 } 277 278 ret = fts_wd_set_resolution(data, resolution); 279 if (ret < 0) 280 return ret; 281 282 wdd->timeout = timeout; 283 return 0; 284 } 285 286 static int fts_wd_start(struct watchdog_device *wdd) 287 { 288 struct fts_data *data = watchdog_get_drvdata(wdd); 289 290 return fts_write_byte(data->client, FTS_WATCHDOG_TIME_PRESET, 291 wdd->timeout / (u8)data->resolution); 292 } 293 294 static int fts_wd_stop(struct watchdog_device *wdd) 295 { 296 struct fts_data *data; 297 298 data = watchdog_get_drvdata(wdd); 299 return fts_write_byte(data->client, FTS_WATCHDOG_TIME_PRESET, 0); 300 } 301 302 static const struct watchdog_info fts_wd_info = { 303 .options = WDIOF_SETTIMEOUT | WDIOF_KEEPALIVEPING | WDIOF_MAGICCLOSE, 304 .identity = "FTS Teutates Hardware Watchdog", 305 }; 306 307 static const struct watchdog_ops fts_wd_ops = { 308 .owner = THIS_MODULE, 309 .start = fts_wd_start, 310 .stop = fts_wd_stop, 311 .set_timeout = fts_wd_set_timeout, 312 }; 313 314 static int fts_watchdog_init(struct fts_data *data) 315 { 316 int timeout, ret; 317 318 watchdog_set_drvdata(&data->wdd, data); 319 320 timeout = fts_read_byte(data->client, FTS_WATCHDOG_TIME_PRESET); 321 if (timeout < 0) 322 return timeout; 323 324 /* watchdog not running, set timeout to a default of 60 sec. */ 325 if (timeout == 0) { 326 ret = fts_wd_set_resolution(data, seconds); 327 if (ret < 0) 328 return ret; 329 data->wdd.timeout = 60; 330 } else { 331 ret = fts_read_byte(data->client, FTS_WATCHDOG_CONTROL); 332 if (ret < 0) 333 return ret; 334 335 data->resolution = ret & BIT(1) ? seconds : minutes; 336 data->wdd.timeout = timeout * (u8)data->resolution; 337 set_bit(WDOG_HW_RUNNING, &data->wdd.status); 338 } 339 340 /* Register our watchdog part */ 341 data->wdd.info = &fts_wd_info; 342 data->wdd.ops = &fts_wd_ops; 343 data->wdd.parent = &data->client->dev; 344 data->wdd.min_timeout = 1; 345 346 /* max timeout 255 minutes. */ 347 data->wdd.max_hw_heartbeat_ms = 0xFF * 60 * MSEC_PER_SEC; 348 349 return watchdog_register_device(&data->wdd); 350 } 351 352 /*****************************************************************************/ 353 /* SysFS handler functions */ 354 /*****************************************************************************/ 355 static ssize_t show_in_value(struct device *dev, 356 struct device_attribute *devattr, char *buf) 357 { 358 struct fts_data *data = dev_get_drvdata(dev); 359 int index = to_sensor_dev_attr(devattr)->index; 360 int err; 361 362 err = fts_update_device(data); 363 if (err < 0) 364 return err; 365 366 return sprintf(buf, "%u\n", data->volt[index]); 367 } 368 369 static ssize_t show_temp_value(struct device *dev, 370 struct device_attribute *devattr, char *buf) 371 { 372 struct fts_data *data = dev_get_drvdata(dev); 373 int index = to_sensor_dev_attr(devattr)->index; 374 int err; 375 376 err = fts_update_device(data); 377 if (err < 0) 378 return err; 379 380 return sprintf(buf, "%u\n", data->temp_input[index]); 381 } 382 383 static ssize_t show_temp_fault(struct device *dev, 384 struct device_attribute *devattr, char *buf) 385 { 386 struct fts_data *data = dev_get_drvdata(dev); 387 int index = to_sensor_dev_attr(devattr)->index; 388 int err; 389 390 err = fts_update_device(data); 391 if (err < 0) 392 return err; 393 394 /* 00h Temperature = Sensor Error */ 395 return sprintf(buf, "%d\n", data->temp_input[index] == 0); 396 } 397 398 static ssize_t show_temp_alarm(struct device *dev, 399 struct device_attribute *devattr, char *buf) 400 { 401 struct fts_data *data = dev_get_drvdata(dev); 402 int index = to_sensor_dev_attr(devattr)->index; 403 int err; 404 405 err = fts_update_device(data); 406 if (err < 0) 407 return err; 408 409 return sprintf(buf, "%u\n", !!(data->temp_alarm & BIT(index))); 410 } 411 412 static ssize_t 413 clear_temp_alarm(struct device *dev, struct device_attribute *devattr, 414 const char *buf, size_t count) 415 { 416 struct fts_data *data = dev_get_drvdata(dev); 417 int index = to_sensor_dev_attr(devattr)->index; 418 long ret; 419 420 ret = fts_update_device(data); 421 if (ret < 0) 422 return ret; 423 424 if (kstrtoul(buf, 10, &ret) || ret != 0) 425 return -EINVAL; 426 427 mutex_lock(&data->update_lock); 428 ret = fts_read_byte(data->client, FTS_REG_TEMP_CONTROL(index)); 429 if (ret < 0) 430 goto error; 431 432 ret = fts_write_byte(data->client, FTS_REG_TEMP_CONTROL(index), 433 ret | 0x1); 434 if (ret < 0) 435 goto error; 436 437 data->valid = false; 438 ret = count; 439 error: 440 mutex_unlock(&data->update_lock); 441 return ret; 442 } 443 444 static ssize_t show_fan_value(struct device *dev, 445 struct device_attribute *devattr, char *buf) 446 { 447 struct fts_data *data = dev_get_drvdata(dev); 448 int index = to_sensor_dev_attr(devattr)->index; 449 int err; 450 451 err = fts_update_device(data); 452 if (err < 0) 453 return err; 454 455 return sprintf(buf, "%u\n", data->fan_input[index]); 456 } 457 458 static ssize_t show_fan_source(struct device *dev, 459 struct device_attribute *devattr, char *buf) 460 { 461 struct fts_data *data = dev_get_drvdata(dev); 462 int index = to_sensor_dev_attr(devattr)->index; 463 int err; 464 465 err = fts_update_device(data); 466 if (err < 0) 467 return err; 468 469 return sprintf(buf, "%u\n", data->fan_source[index]); 470 } 471 472 static ssize_t show_fan_alarm(struct device *dev, 473 struct device_attribute *devattr, char *buf) 474 { 475 struct fts_data *data = dev_get_drvdata(dev); 476 int index = to_sensor_dev_attr(devattr)->index; 477 int err; 478 479 err = fts_update_device(data); 480 if (err < 0) 481 return err; 482 483 return sprintf(buf, "%d\n", !!(data->fan_alarm & BIT(index))); 484 } 485 486 static ssize_t 487 clear_fan_alarm(struct device *dev, struct device_attribute *devattr, 488 const char *buf, size_t count) 489 { 490 struct fts_data *data = dev_get_drvdata(dev); 491 int index = to_sensor_dev_attr(devattr)->index; 492 long ret; 493 494 ret = fts_update_device(data); 495 if (ret < 0) 496 return ret; 497 498 if (kstrtoul(buf, 10, &ret) || ret != 0) 499 return -EINVAL; 500 501 mutex_lock(&data->update_lock); 502 ret = fts_read_byte(data->client, FTS_REG_FAN_CONTROL(index)); 503 if (ret < 0) 504 goto error; 505 506 ret = fts_write_byte(data->client, FTS_REG_FAN_CONTROL(index), 507 ret | 0x1); 508 if (ret < 0) 509 goto error; 510 511 data->valid = false; 512 ret = count; 513 error: 514 mutex_unlock(&data->update_lock); 515 return ret; 516 } 517 518 /*****************************************************************************/ 519 /* SysFS structs */ 520 /*****************************************************************************/ 521 522 /* Temprature sensors */ 523 static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, show_temp_value, NULL, 0); 524 static SENSOR_DEVICE_ATTR(temp2_input, S_IRUGO, show_temp_value, NULL, 1); 525 static SENSOR_DEVICE_ATTR(temp3_input, S_IRUGO, show_temp_value, NULL, 2); 526 static SENSOR_DEVICE_ATTR(temp4_input, S_IRUGO, show_temp_value, NULL, 3); 527 static SENSOR_DEVICE_ATTR(temp5_input, S_IRUGO, show_temp_value, NULL, 4); 528 static SENSOR_DEVICE_ATTR(temp6_input, S_IRUGO, show_temp_value, NULL, 5); 529 static SENSOR_DEVICE_ATTR(temp7_input, S_IRUGO, show_temp_value, NULL, 6); 530 static SENSOR_DEVICE_ATTR(temp8_input, S_IRUGO, show_temp_value, NULL, 7); 531 static SENSOR_DEVICE_ATTR(temp9_input, S_IRUGO, show_temp_value, NULL, 8); 532 static SENSOR_DEVICE_ATTR(temp10_input, S_IRUGO, show_temp_value, NULL, 9); 533 static SENSOR_DEVICE_ATTR(temp11_input, S_IRUGO, show_temp_value, NULL, 10); 534 static SENSOR_DEVICE_ATTR(temp12_input, S_IRUGO, show_temp_value, NULL, 11); 535 static SENSOR_DEVICE_ATTR(temp13_input, S_IRUGO, show_temp_value, NULL, 12); 536 static SENSOR_DEVICE_ATTR(temp14_input, S_IRUGO, show_temp_value, NULL, 13); 537 static SENSOR_DEVICE_ATTR(temp15_input, S_IRUGO, show_temp_value, NULL, 14); 538 static SENSOR_DEVICE_ATTR(temp16_input, S_IRUGO, show_temp_value, NULL, 15); 539 540 static SENSOR_DEVICE_ATTR(temp1_fault, S_IRUGO, show_temp_fault, NULL, 0); 541 static SENSOR_DEVICE_ATTR(temp2_fault, S_IRUGO, show_temp_fault, NULL, 1); 542 static SENSOR_DEVICE_ATTR(temp3_fault, S_IRUGO, show_temp_fault, NULL, 2); 543 static SENSOR_DEVICE_ATTR(temp4_fault, S_IRUGO, show_temp_fault, NULL, 3); 544 static SENSOR_DEVICE_ATTR(temp5_fault, S_IRUGO, show_temp_fault, NULL, 4); 545 static SENSOR_DEVICE_ATTR(temp6_fault, S_IRUGO, show_temp_fault, NULL, 5); 546 static SENSOR_DEVICE_ATTR(temp7_fault, S_IRUGO, show_temp_fault, NULL, 6); 547 static SENSOR_DEVICE_ATTR(temp8_fault, S_IRUGO, show_temp_fault, NULL, 7); 548 static SENSOR_DEVICE_ATTR(temp9_fault, S_IRUGO, show_temp_fault, NULL, 8); 549 static SENSOR_DEVICE_ATTR(temp10_fault, S_IRUGO, show_temp_fault, NULL, 9); 550 static SENSOR_DEVICE_ATTR(temp11_fault, S_IRUGO, show_temp_fault, NULL, 10); 551 static SENSOR_DEVICE_ATTR(temp12_fault, S_IRUGO, show_temp_fault, NULL, 11); 552 static SENSOR_DEVICE_ATTR(temp13_fault, S_IRUGO, show_temp_fault, NULL, 12); 553 static SENSOR_DEVICE_ATTR(temp14_fault, S_IRUGO, show_temp_fault, NULL, 13); 554 static SENSOR_DEVICE_ATTR(temp15_fault, S_IRUGO, show_temp_fault, NULL, 14); 555 static SENSOR_DEVICE_ATTR(temp16_fault, S_IRUGO, show_temp_fault, NULL, 15); 556 557 static SENSOR_DEVICE_ATTR(temp1_alarm, S_IRUGO | S_IWUSR, show_temp_alarm, 558 clear_temp_alarm, 0); 559 static SENSOR_DEVICE_ATTR(temp2_alarm, S_IRUGO | S_IWUSR, show_temp_alarm, 560 clear_temp_alarm, 1); 561 static SENSOR_DEVICE_ATTR(temp3_alarm, S_IRUGO | S_IWUSR, show_temp_alarm, 562 clear_temp_alarm, 2); 563 static SENSOR_DEVICE_ATTR(temp4_alarm, S_IRUGO | S_IWUSR, show_temp_alarm, 564 clear_temp_alarm, 3); 565 static SENSOR_DEVICE_ATTR(temp5_alarm, S_IRUGO | S_IWUSR, show_temp_alarm, 566 clear_temp_alarm, 4); 567 static SENSOR_DEVICE_ATTR(temp6_alarm, S_IRUGO | S_IWUSR, show_temp_alarm, 568 clear_temp_alarm, 5); 569 static SENSOR_DEVICE_ATTR(temp7_alarm, S_IRUGO | S_IWUSR, show_temp_alarm, 570 clear_temp_alarm, 6); 571 static SENSOR_DEVICE_ATTR(temp8_alarm, S_IRUGO | S_IWUSR, show_temp_alarm, 572 clear_temp_alarm, 7); 573 static SENSOR_DEVICE_ATTR(temp9_alarm, S_IRUGO | S_IWUSR, show_temp_alarm, 574 clear_temp_alarm, 8); 575 static SENSOR_DEVICE_ATTR(temp10_alarm, S_IRUGO | S_IWUSR, show_temp_alarm, 576 clear_temp_alarm, 9); 577 static SENSOR_DEVICE_ATTR(temp11_alarm, S_IRUGO | S_IWUSR, show_temp_alarm, 578 clear_temp_alarm, 10); 579 static SENSOR_DEVICE_ATTR(temp12_alarm, S_IRUGO | S_IWUSR, show_temp_alarm, 580 clear_temp_alarm, 11); 581 static SENSOR_DEVICE_ATTR(temp13_alarm, S_IRUGO | S_IWUSR, show_temp_alarm, 582 clear_temp_alarm, 12); 583 static SENSOR_DEVICE_ATTR(temp14_alarm, S_IRUGO | S_IWUSR, show_temp_alarm, 584 clear_temp_alarm, 13); 585 static SENSOR_DEVICE_ATTR(temp15_alarm, S_IRUGO | S_IWUSR, show_temp_alarm, 586 clear_temp_alarm, 14); 587 static SENSOR_DEVICE_ATTR(temp16_alarm, S_IRUGO | S_IWUSR, show_temp_alarm, 588 clear_temp_alarm, 15); 589 590 static struct attribute *fts_temp_attrs[] = { 591 &sensor_dev_attr_temp1_input.dev_attr.attr, 592 &sensor_dev_attr_temp2_input.dev_attr.attr, 593 &sensor_dev_attr_temp3_input.dev_attr.attr, 594 &sensor_dev_attr_temp4_input.dev_attr.attr, 595 &sensor_dev_attr_temp5_input.dev_attr.attr, 596 &sensor_dev_attr_temp6_input.dev_attr.attr, 597 &sensor_dev_attr_temp7_input.dev_attr.attr, 598 &sensor_dev_attr_temp8_input.dev_attr.attr, 599 &sensor_dev_attr_temp9_input.dev_attr.attr, 600 &sensor_dev_attr_temp10_input.dev_attr.attr, 601 &sensor_dev_attr_temp11_input.dev_attr.attr, 602 &sensor_dev_attr_temp12_input.dev_attr.attr, 603 &sensor_dev_attr_temp13_input.dev_attr.attr, 604 &sensor_dev_attr_temp14_input.dev_attr.attr, 605 &sensor_dev_attr_temp15_input.dev_attr.attr, 606 &sensor_dev_attr_temp16_input.dev_attr.attr, 607 608 &sensor_dev_attr_temp1_fault.dev_attr.attr, 609 &sensor_dev_attr_temp2_fault.dev_attr.attr, 610 &sensor_dev_attr_temp3_fault.dev_attr.attr, 611 &sensor_dev_attr_temp4_fault.dev_attr.attr, 612 &sensor_dev_attr_temp5_fault.dev_attr.attr, 613 &sensor_dev_attr_temp6_fault.dev_attr.attr, 614 &sensor_dev_attr_temp7_fault.dev_attr.attr, 615 &sensor_dev_attr_temp8_fault.dev_attr.attr, 616 &sensor_dev_attr_temp9_fault.dev_attr.attr, 617 &sensor_dev_attr_temp10_fault.dev_attr.attr, 618 &sensor_dev_attr_temp11_fault.dev_attr.attr, 619 &sensor_dev_attr_temp12_fault.dev_attr.attr, 620 &sensor_dev_attr_temp13_fault.dev_attr.attr, 621 &sensor_dev_attr_temp14_fault.dev_attr.attr, 622 &sensor_dev_attr_temp15_fault.dev_attr.attr, 623 &sensor_dev_attr_temp16_fault.dev_attr.attr, 624 625 &sensor_dev_attr_temp1_alarm.dev_attr.attr, 626 &sensor_dev_attr_temp2_alarm.dev_attr.attr, 627 &sensor_dev_attr_temp3_alarm.dev_attr.attr, 628 &sensor_dev_attr_temp4_alarm.dev_attr.attr, 629 &sensor_dev_attr_temp5_alarm.dev_attr.attr, 630 &sensor_dev_attr_temp6_alarm.dev_attr.attr, 631 &sensor_dev_attr_temp7_alarm.dev_attr.attr, 632 &sensor_dev_attr_temp8_alarm.dev_attr.attr, 633 &sensor_dev_attr_temp9_alarm.dev_attr.attr, 634 &sensor_dev_attr_temp10_alarm.dev_attr.attr, 635 &sensor_dev_attr_temp11_alarm.dev_attr.attr, 636 &sensor_dev_attr_temp12_alarm.dev_attr.attr, 637 &sensor_dev_attr_temp13_alarm.dev_attr.attr, 638 &sensor_dev_attr_temp14_alarm.dev_attr.attr, 639 &sensor_dev_attr_temp15_alarm.dev_attr.attr, 640 &sensor_dev_attr_temp16_alarm.dev_attr.attr, 641 NULL 642 }; 643 644 /* Fans */ 645 static SENSOR_DEVICE_ATTR(fan1_input, S_IRUGO, show_fan_value, NULL, 0); 646 static SENSOR_DEVICE_ATTR(fan2_input, S_IRUGO, show_fan_value, NULL, 1); 647 static SENSOR_DEVICE_ATTR(fan3_input, S_IRUGO, show_fan_value, NULL, 2); 648 static SENSOR_DEVICE_ATTR(fan4_input, S_IRUGO, show_fan_value, NULL, 3); 649 static SENSOR_DEVICE_ATTR(fan5_input, S_IRUGO, show_fan_value, NULL, 4); 650 static SENSOR_DEVICE_ATTR(fan6_input, S_IRUGO, show_fan_value, NULL, 5); 651 static SENSOR_DEVICE_ATTR(fan7_input, S_IRUGO, show_fan_value, NULL, 6); 652 static SENSOR_DEVICE_ATTR(fan8_input, S_IRUGO, show_fan_value, NULL, 7); 653 654 static SENSOR_DEVICE_ATTR(fan1_source, S_IRUGO, show_fan_source, NULL, 0); 655 static SENSOR_DEVICE_ATTR(fan2_source, S_IRUGO, show_fan_source, NULL, 1); 656 static SENSOR_DEVICE_ATTR(fan3_source, S_IRUGO, show_fan_source, NULL, 2); 657 static SENSOR_DEVICE_ATTR(fan4_source, S_IRUGO, show_fan_source, NULL, 3); 658 static SENSOR_DEVICE_ATTR(fan5_source, S_IRUGO, show_fan_source, NULL, 4); 659 static SENSOR_DEVICE_ATTR(fan6_source, S_IRUGO, show_fan_source, NULL, 5); 660 static SENSOR_DEVICE_ATTR(fan7_source, S_IRUGO, show_fan_source, NULL, 6); 661 static SENSOR_DEVICE_ATTR(fan8_source, S_IRUGO, show_fan_source, NULL, 7); 662 663 static SENSOR_DEVICE_ATTR(fan1_alarm, S_IRUGO | S_IWUSR, 664 show_fan_alarm, clear_fan_alarm, 0); 665 static SENSOR_DEVICE_ATTR(fan2_alarm, S_IRUGO | S_IWUSR, 666 show_fan_alarm, clear_fan_alarm, 1); 667 static SENSOR_DEVICE_ATTR(fan3_alarm, S_IRUGO | S_IWUSR, 668 show_fan_alarm, clear_fan_alarm, 2); 669 static SENSOR_DEVICE_ATTR(fan4_alarm, S_IRUGO | S_IWUSR, 670 show_fan_alarm, clear_fan_alarm, 3); 671 static SENSOR_DEVICE_ATTR(fan5_alarm, S_IRUGO | S_IWUSR, 672 show_fan_alarm, clear_fan_alarm, 4); 673 static SENSOR_DEVICE_ATTR(fan6_alarm, S_IRUGO | S_IWUSR, 674 show_fan_alarm, clear_fan_alarm, 5); 675 static SENSOR_DEVICE_ATTR(fan7_alarm, S_IRUGO | S_IWUSR, 676 show_fan_alarm, clear_fan_alarm, 6); 677 static SENSOR_DEVICE_ATTR(fan8_alarm, S_IRUGO | S_IWUSR, 678 show_fan_alarm, clear_fan_alarm, 7); 679 680 static struct attribute *fts_fan_attrs[] = { 681 &sensor_dev_attr_fan1_input.dev_attr.attr, 682 &sensor_dev_attr_fan2_input.dev_attr.attr, 683 &sensor_dev_attr_fan3_input.dev_attr.attr, 684 &sensor_dev_attr_fan4_input.dev_attr.attr, 685 &sensor_dev_attr_fan5_input.dev_attr.attr, 686 &sensor_dev_attr_fan6_input.dev_attr.attr, 687 &sensor_dev_attr_fan7_input.dev_attr.attr, 688 &sensor_dev_attr_fan8_input.dev_attr.attr, 689 690 &sensor_dev_attr_fan1_source.dev_attr.attr, 691 &sensor_dev_attr_fan2_source.dev_attr.attr, 692 &sensor_dev_attr_fan3_source.dev_attr.attr, 693 &sensor_dev_attr_fan4_source.dev_attr.attr, 694 &sensor_dev_attr_fan5_source.dev_attr.attr, 695 &sensor_dev_attr_fan6_source.dev_attr.attr, 696 &sensor_dev_attr_fan7_source.dev_attr.attr, 697 &sensor_dev_attr_fan8_source.dev_attr.attr, 698 699 &sensor_dev_attr_fan1_alarm.dev_attr.attr, 700 &sensor_dev_attr_fan2_alarm.dev_attr.attr, 701 &sensor_dev_attr_fan3_alarm.dev_attr.attr, 702 &sensor_dev_attr_fan4_alarm.dev_attr.attr, 703 &sensor_dev_attr_fan5_alarm.dev_attr.attr, 704 &sensor_dev_attr_fan6_alarm.dev_attr.attr, 705 &sensor_dev_attr_fan7_alarm.dev_attr.attr, 706 &sensor_dev_attr_fan8_alarm.dev_attr.attr, 707 NULL 708 }; 709 710 /* Voltages */ 711 static SENSOR_DEVICE_ATTR(in1_input, S_IRUGO, show_in_value, NULL, 0); 712 static SENSOR_DEVICE_ATTR(in2_input, S_IRUGO, show_in_value, NULL, 1); 713 static SENSOR_DEVICE_ATTR(in3_input, S_IRUGO, show_in_value, NULL, 2); 714 static SENSOR_DEVICE_ATTR(in4_input, S_IRUGO, show_in_value, NULL, 3); 715 static struct attribute *fts_voltage_attrs[] = { 716 &sensor_dev_attr_in1_input.dev_attr.attr, 717 &sensor_dev_attr_in2_input.dev_attr.attr, 718 &sensor_dev_attr_in3_input.dev_attr.attr, 719 &sensor_dev_attr_in4_input.dev_attr.attr, 720 NULL 721 }; 722 723 static const struct attribute_group fts_voltage_attr_group = { 724 .attrs = fts_voltage_attrs 725 }; 726 727 static const struct attribute_group fts_temp_attr_group = { 728 .attrs = fts_temp_attrs 729 }; 730 731 static const struct attribute_group fts_fan_attr_group = { 732 .attrs = fts_fan_attrs 733 }; 734 735 static const struct attribute_group *fts_attr_groups[] = { 736 &fts_voltage_attr_group, 737 &fts_temp_attr_group, 738 &fts_fan_attr_group, 739 NULL 740 }; 741 742 /*****************************************************************************/ 743 /* Module initialization / remove functions */ 744 /*****************************************************************************/ 745 static int fts_detect(struct i2c_client *client, 746 struct i2c_board_info *info) 747 { 748 int val; 749 750 /* detection works with revsion greater or equal to 0x2b */ 751 val = i2c_smbus_read_byte_data(client, FTS_DEVICE_REVISION_REG); 752 if (val < 0x2b) 753 return -ENODEV; 754 755 /* Device Detect Regs must have 0x17 0x34 and 0x54 */ 756 val = i2c_smbus_read_byte_data(client, FTS_DEVICE_DETECT_REG_1); 757 if (val != 0x17) 758 return -ENODEV; 759 760 val = i2c_smbus_read_byte_data(client, FTS_DEVICE_DETECT_REG_2); 761 if (val != 0x34) 762 return -ENODEV; 763 764 val = i2c_smbus_read_byte_data(client, FTS_DEVICE_DETECT_REG_3); 765 if (val != 0x54) 766 return -ENODEV; 767 768 /* 769 * 0x10 == Baseboard Management Controller, 0x01 == Teutates 770 * Device ID Reg needs to be 0x11 771 */ 772 val = i2c_smbus_read_byte_data(client, FTS_DEVICE_ID_REG); 773 if (val != 0x11) 774 return -ENODEV; 775 776 strlcpy(info->type, fts_id[0].name, I2C_NAME_SIZE); 777 info->flags = 0; 778 return 0; 779 } 780 781 static int fts_remove(struct i2c_client *client) 782 { 783 struct fts_data *data = dev_get_drvdata(&client->dev); 784 785 watchdog_unregister_device(&data->wdd); 786 return 0; 787 } 788 789 static int fts_probe(struct i2c_client *client, const struct i2c_device_id *id) 790 { 791 u8 revision; 792 struct fts_data *data; 793 int err; 794 s8 deviceid; 795 struct device *hwmon_dev; 796 797 if (client->addr != 0x73) 798 return -ENODEV; 799 800 /* Baseboard Management Controller check */ 801 deviceid = i2c_smbus_read_byte_data(client, FTS_DEVICE_ID_REG); 802 if (deviceid > 0 && (deviceid & 0xF0) == 0x10) { 803 switch (deviceid & 0x0F) { 804 case 0x01: 805 break; 806 default: 807 dev_dbg(&client->dev, 808 "No Baseboard Management Controller\n"); 809 return -ENODEV; 810 } 811 } else { 812 dev_dbg(&client->dev, "No fujitsu board\n"); 813 return -ENODEV; 814 } 815 816 data = devm_kzalloc(&client->dev, sizeof(struct fts_data), 817 GFP_KERNEL); 818 if (!data) 819 return -ENOMEM; 820 821 mutex_init(&data->update_lock); 822 mutex_init(&data->access_lock); 823 data->client = client; 824 dev_set_drvdata(&client->dev, data); 825 826 err = i2c_smbus_read_byte_data(client, FTS_DEVICE_REVISION_REG); 827 if (err < 0) 828 return err; 829 revision = err; 830 831 hwmon_dev = devm_hwmon_device_register_with_groups(&client->dev, 832 "ftsteutates", 833 data, 834 fts_attr_groups); 835 if (IS_ERR(hwmon_dev)) 836 return PTR_ERR(hwmon_dev); 837 838 err = fts_watchdog_init(data); 839 if (err) 840 return err; 841 842 dev_info(&client->dev, "Detected FTS Teutates chip, revision: %d.%d\n", 843 (revision & 0xF0) >> 4, revision & 0x0F); 844 return 0; 845 } 846 847 /*****************************************************************************/ 848 /* Module Details */ 849 /*****************************************************************************/ 850 static struct i2c_driver fts_driver = { 851 .class = I2C_CLASS_HWMON, 852 .driver = { 853 .name = "ftsteutates", 854 }, 855 .id_table = fts_id, 856 .probe = fts_probe, 857 .remove = fts_remove, 858 .detect = fts_detect, 859 .address_list = normal_i2c, 860 }; 861 862 module_i2c_driver(fts_driver); 863 864 MODULE_AUTHOR("Thilo Cestonaro <thilo.cestonaro@ts.fujitsu.com>"); 865 MODULE_DESCRIPTION("FTS Teutates driver"); 866 MODULE_LICENSE("GPL"); 867