1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * Support for the FTS Systemmonitoring Chip "Teutates" 4 * 5 * Copyright (C) 2016 Fujitsu Technology Solutions GmbH, 6 * Thilo Cestonaro <thilo.cestonaro@ts.fujitsu.com> 7 */ 8 #include <linux/err.h> 9 #include <linux/hwmon.h> 10 #include <linux/i2c.h> 11 #include <linux/init.h> 12 #include <linux/jiffies.h> 13 #include <linux/math.h> 14 #include <linux/module.h> 15 #include <linux/mutex.h> 16 #include <linux/slab.h> 17 #include <linux/watchdog.h> 18 19 #define FTS_DEVICE_ID_REG 0x0000 20 #define FTS_DEVICE_REVISION_REG 0x0001 21 #define FTS_DEVICE_STATUS_REG 0x0004 22 #define FTS_SATELLITE_STATUS_REG 0x0005 23 #define FTS_EVENT_STATUS_REG 0x0006 24 #define FTS_GLOBAL_CONTROL_REG 0x0007 25 26 #define FTS_DEVICE_DETECT_REG_1 0x0C 27 #define FTS_DEVICE_DETECT_REG_2 0x0D 28 #define FTS_DEVICE_DETECT_REG_3 0x0E 29 30 #define FTS_SENSOR_EVENT_REG 0x0010 31 32 #define FTS_FAN_EVENT_REG 0x0014 33 #define FTS_FAN_PRESENT_REG 0x0015 34 35 #define FTS_POWER_ON_TIME_COUNTER_A 0x007A 36 #define FTS_POWER_ON_TIME_COUNTER_B 0x007B 37 #define FTS_POWER_ON_TIME_COUNTER_C 0x007C 38 39 #define FTS_PAGE_SELECT_REG 0x007F 40 41 #define FTS_WATCHDOG_TIME_PRESET 0x000B 42 #define FTS_WATCHDOG_CONTROL 0x5081 43 44 #define FTS_NO_FAN_SENSORS 0x08 45 #define FTS_NO_TEMP_SENSORS 0x10 46 #define FTS_NO_VOLT_SENSORS 0x04 47 48 #define FTS_FAN_SOURCE_INVALID 0xff 49 50 static const unsigned short normal_i2c[] = { 0x73, I2C_CLIENT_END }; 51 52 static const struct i2c_device_id fts_id[] = { 53 { "ftsteutates" }, 54 { } 55 }; 56 MODULE_DEVICE_TABLE(i2c, fts_id); 57 58 enum WATCHDOG_RESOLUTION { 59 seconds = 1, 60 minutes = 60 61 }; 62 63 struct fts_data { 64 struct i2c_client *client; 65 /* update sensor data lock */ 66 struct mutex update_lock; 67 /* read/write register lock */ 68 struct mutex access_lock; 69 unsigned long last_updated; /* in jiffies */ 70 struct watchdog_device wdd; 71 enum WATCHDOG_RESOLUTION resolution; 72 bool valid; /* false until following fields are valid */ 73 74 u8 volt[FTS_NO_VOLT_SENSORS]; 75 76 u8 temp_input[FTS_NO_TEMP_SENSORS]; 77 u8 temp_alarm; 78 79 u8 fan_present; 80 u8 fan_input[FTS_NO_FAN_SENSORS]; /* in rps */ 81 u8 fan_source[FTS_NO_FAN_SENSORS]; 82 u8 fan_alarm; 83 }; 84 85 #define FTS_REG_FAN_INPUT(idx) ((idx) + 0x20) 86 #define FTS_REG_FAN_SOURCE(idx) ((idx) + 0x30) 87 #define FTS_REG_FAN_CONTROL(idx) (((idx) << 16) + 0x4881) 88 89 #define FTS_REG_TEMP_INPUT(idx) ((idx) + 0x40) 90 #define FTS_REG_TEMP_CONTROL(idx) (((idx) << 16) + 0x0681) 91 92 #define FTS_REG_VOLT(idx) ((idx) + 0x18) 93 94 /*****************************************************************************/ 95 /* I2C Helper functions */ 96 /*****************************************************************************/ 97 static int fts_read_byte(struct i2c_client *client, unsigned short reg) 98 { 99 int ret; 100 unsigned char page = reg >> 8; 101 struct fts_data *data = dev_get_drvdata(&client->dev); 102 103 mutex_lock(&data->access_lock); 104 105 dev_dbg(&client->dev, "page select - page: 0x%.02x\n", page); 106 ret = i2c_smbus_write_byte_data(client, FTS_PAGE_SELECT_REG, page); 107 if (ret < 0) 108 goto error; 109 110 reg &= 0xFF; 111 ret = i2c_smbus_read_byte_data(client, reg); 112 dev_dbg(&client->dev, "read - reg: 0x%.02x: val: 0x%.02x\n", reg, ret); 113 114 error: 115 mutex_unlock(&data->access_lock); 116 return ret; 117 } 118 119 static int fts_write_byte(struct i2c_client *client, unsigned short reg, 120 unsigned char value) 121 { 122 int ret; 123 unsigned char page = reg >> 8; 124 struct fts_data *data = dev_get_drvdata(&client->dev); 125 126 mutex_lock(&data->access_lock); 127 128 dev_dbg(&client->dev, "page select - page: 0x%.02x\n", page); 129 ret = i2c_smbus_write_byte_data(client, FTS_PAGE_SELECT_REG, page); 130 if (ret < 0) 131 goto error; 132 133 reg &= 0xFF; 134 dev_dbg(&client->dev, 135 "write - reg: 0x%.02x: val: 0x%.02x\n", reg, value); 136 ret = i2c_smbus_write_byte_data(client, reg, value); 137 138 error: 139 mutex_unlock(&data->access_lock); 140 return ret; 141 } 142 143 /*****************************************************************************/ 144 /* Data Updater Helper function */ 145 /*****************************************************************************/ 146 static int fts_update_device(struct fts_data *data) 147 { 148 int i; 149 int err = 0; 150 151 mutex_lock(&data->update_lock); 152 if (!time_after(jiffies, data->last_updated + 2 * HZ) && data->valid) 153 goto exit; 154 155 err = fts_read_byte(data->client, FTS_DEVICE_STATUS_REG); 156 if (err < 0) 157 goto exit; 158 159 data->valid = !!(err & 0x02); /* Data not ready yet */ 160 if (unlikely(!data->valid)) { 161 err = -EAGAIN; 162 goto exit; 163 } 164 165 err = fts_read_byte(data->client, FTS_FAN_PRESENT_REG); 166 if (err < 0) 167 goto exit; 168 data->fan_present = err; 169 170 err = fts_read_byte(data->client, FTS_FAN_EVENT_REG); 171 if (err < 0) 172 goto exit; 173 data->fan_alarm = err; 174 175 for (i = 0; i < FTS_NO_FAN_SENSORS; i++) { 176 if (data->fan_present & BIT(i)) { 177 err = fts_read_byte(data->client, FTS_REG_FAN_INPUT(i)); 178 if (err < 0) 179 goto exit; 180 data->fan_input[i] = err; 181 182 err = fts_read_byte(data->client, 183 FTS_REG_FAN_SOURCE(i)); 184 if (err < 0) 185 goto exit; 186 data->fan_source[i] = err; 187 } else { 188 data->fan_input[i] = 0; 189 data->fan_source[i] = FTS_FAN_SOURCE_INVALID; 190 } 191 } 192 193 err = fts_read_byte(data->client, FTS_SENSOR_EVENT_REG); 194 if (err < 0) 195 goto exit; 196 data->temp_alarm = err; 197 198 for (i = 0; i < FTS_NO_TEMP_SENSORS; i++) { 199 err = fts_read_byte(data->client, FTS_REG_TEMP_INPUT(i)); 200 if (err < 0) 201 goto exit; 202 data->temp_input[i] = err; 203 } 204 205 for (i = 0; i < FTS_NO_VOLT_SENSORS; i++) { 206 err = fts_read_byte(data->client, FTS_REG_VOLT(i)); 207 if (err < 0) 208 goto exit; 209 data->volt[i] = err; 210 } 211 data->last_updated = jiffies; 212 err = 0; 213 exit: 214 mutex_unlock(&data->update_lock); 215 return err; 216 } 217 218 /*****************************************************************************/ 219 /* Watchdog functions */ 220 /*****************************************************************************/ 221 static int fts_wd_set_resolution(struct fts_data *data, 222 enum WATCHDOG_RESOLUTION resolution) 223 { 224 int ret; 225 226 if (data->resolution == resolution) 227 return 0; 228 229 ret = fts_read_byte(data->client, FTS_WATCHDOG_CONTROL); 230 if (ret < 0) 231 return ret; 232 233 if ((resolution == seconds && ret & BIT(1)) || 234 (resolution == minutes && (ret & BIT(1)) == 0)) { 235 data->resolution = resolution; 236 return 0; 237 } 238 239 if (resolution == seconds) 240 ret |= BIT(1); 241 else 242 ret &= ~BIT(1); 243 244 ret = fts_write_byte(data->client, FTS_WATCHDOG_CONTROL, ret); 245 if (ret < 0) 246 return ret; 247 248 data->resolution = resolution; 249 return ret; 250 } 251 252 static int fts_wd_set_timeout(struct watchdog_device *wdd, unsigned int timeout) 253 { 254 struct fts_data *data; 255 enum WATCHDOG_RESOLUTION resolution = seconds; 256 int ret; 257 258 data = watchdog_get_drvdata(wdd); 259 /* switch watchdog resolution to minutes if timeout does not fit 260 * into a byte 261 */ 262 if (timeout > 0xFF) { 263 timeout = DIV_ROUND_UP(timeout, 60) * 60; 264 resolution = minutes; 265 } 266 267 ret = fts_wd_set_resolution(data, resolution); 268 if (ret < 0) 269 return ret; 270 271 wdd->timeout = timeout; 272 return 0; 273 } 274 275 static int fts_wd_start(struct watchdog_device *wdd) 276 { 277 struct fts_data *data = watchdog_get_drvdata(wdd); 278 279 return fts_write_byte(data->client, FTS_WATCHDOG_TIME_PRESET, 280 wdd->timeout / (u8)data->resolution); 281 } 282 283 static int fts_wd_stop(struct watchdog_device *wdd) 284 { 285 struct fts_data *data; 286 287 data = watchdog_get_drvdata(wdd); 288 return fts_write_byte(data->client, FTS_WATCHDOG_TIME_PRESET, 0); 289 } 290 291 static const struct watchdog_info fts_wd_info = { 292 .options = WDIOF_SETTIMEOUT | WDIOF_KEEPALIVEPING | WDIOF_MAGICCLOSE, 293 .identity = "FTS Teutates Hardware Watchdog", 294 }; 295 296 static const struct watchdog_ops fts_wd_ops = { 297 .owner = THIS_MODULE, 298 .start = fts_wd_start, 299 .stop = fts_wd_stop, 300 .set_timeout = fts_wd_set_timeout, 301 }; 302 303 static int fts_watchdog_init(struct fts_data *data) 304 { 305 int timeout, ret; 306 307 watchdog_set_drvdata(&data->wdd, data); 308 309 timeout = fts_read_byte(data->client, FTS_WATCHDOG_TIME_PRESET); 310 if (timeout < 0) 311 return timeout; 312 313 /* watchdog not running, set timeout to a default of 60 sec. */ 314 if (timeout == 0) { 315 ret = fts_wd_set_resolution(data, seconds); 316 if (ret < 0) 317 return ret; 318 data->wdd.timeout = 60; 319 } else { 320 ret = fts_read_byte(data->client, FTS_WATCHDOG_CONTROL); 321 if (ret < 0) 322 return ret; 323 324 data->resolution = ret & BIT(1) ? seconds : minutes; 325 data->wdd.timeout = timeout * (u8)data->resolution; 326 set_bit(WDOG_HW_RUNNING, &data->wdd.status); 327 } 328 329 /* Register our watchdog part */ 330 data->wdd.info = &fts_wd_info; 331 data->wdd.ops = &fts_wd_ops; 332 data->wdd.parent = &data->client->dev; 333 data->wdd.min_timeout = 1; 334 335 /* max timeout 255 minutes. */ 336 data->wdd.max_hw_heartbeat_ms = 0xFF * 60 * MSEC_PER_SEC; 337 338 return devm_watchdog_register_device(&data->client->dev, &data->wdd); 339 } 340 341 static umode_t fts_is_visible(const void *devdata, enum hwmon_sensor_types type, u32 attr, 342 int channel) 343 { 344 switch (type) { 345 case hwmon_temp: 346 switch (attr) { 347 case hwmon_temp_input: 348 case hwmon_temp_fault: 349 return 0444; 350 case hwmon_temp_alarm: 351 return 0644; 352 default: 353 break; 354 } 355 break; 356 case hwmon_fan: 357 switch (attr) { 358 case hwmon_fan_input: 359 case hwmon_fan_fault: 360 return 0444; 361 case hwmon_fan_alarm: 362 return 0644; 363 default: 364 break; 365 } 366 break; 367 case hwmon_pwm: 368 case hwmon_in: 369 return 0444; 370 default: 371 break; 372 } 373 374 return 0; 375 } 376 377 static int fts_read(struct device *dev, enum hwmon_sensor_types type, u32 attr, int channel, 378 long *val) 379 { 380 struct fts_data *data = dev_get_drvdata(dev); 381 int ret = fts_update_device(data); 382 383 if (ret < 0) 384 return ret; 385 386 switch (type) { 387 case hwmon_temp: 388 switch (attr) { 389 case hwmon_temp_input: 390 *val = (data->temp_input[channel] - 64) * 1000; 391 392 return 0; 393 case hwmon_temp_alarm: 394 *val = !!(data->temp_alarm & BIT(channel)); 395 396 return 0; 397 case hwmon_temp_fault: 398 /* 00h Temperature = Sensor Error */; 399 *val = (data->temp_input[channel] == 0); 400 401 return 0; 402 default: 403 break; 404 } 405 break; 406 case hwmon_fan: 407 switch (attr) { 408 case hwmon_fan_input: 409 *val = data->fan_input[channel] * 60; 410 411 return 0; 412 case hwmon_fan_alarm: 413 *val = !!(data->fan_alarm & BIT(channel)); 414 415 return 0; 416 case hwmon_fan_fault: 417 *val = !(data->fan_present & BIT(channel)); 418 419 return 0; 420 default: 421 break; 422 } 423 break; 424 case hwmon_pwm: 425 switch (attr) { 426 case hwmon_pwm_auto_channels_temp: { 427 u8 fan_source = data->fan_source[channel]; 428 429 if (fan_source == FTS_FAN_SOURCE_INVALID || fan_source >= BITS_PER_LONG) 430 *val = 0; 431 else 432 *val = BIT(fan_source); 433 434 return 0; 435 } 436 default: 437 break; 438 } 439 break; 440 case hwmon_in: 441 switch (attr) { 442 case hwmon_in_input: 443 *val = DIV_ROUND_CLOSEST(data->volt[channel] * 3300, 255); 444 445 return 0; 446 default: 447 break; 448 } 449 break; 450 default: 451 break; 452 } 453 454 return -EOPNOTSUPP; 455 } 456 457 static int fts_write(struct device *dev, enum hwmon_sensor_types type, u32 attr, int channel, 458 long val) 459 { 460 struct fts_data *data = dev_get_drvdata(dev); 461 int ret = fts_update_device(data); 462 463 if (ret < 0) 464 return ret; 465 466 switch (type) { 467 case hwmon_temp: 468 switch (attr) { 469 case hwmon_temp_alarm: 470 if (val) 471 return -EINVAL; 472 473 mutex_lock(&data->update_lock); 474 ret = fts_read_byte(data->client, FTS_REG_TEMP_CONTROL(channel)); 475 if (ret >= 0) 476 ret = fts_write_byte(data->client, FTS_REG_TEMP_CONTROL(channel), 477 ret | 0x1); 478 if (ret >= 0) 479 data->valid = false; 480 481 mutex_unlock(&data->update_lock); 482 if (ret < 0) 483 return ret; 484 485 return 0; 486 default: 487 break; 488 } 489 break; 490 case hwmon_fan: 491 switch (attr) { 492 case hwmon_fan_alarm: 493 if (val) 494 return -EINVAL; 495 496 mutex_lock(&data->update_lock); 497 ret = fts_read_byte(data->client, FTS_REG_FAN_CONTROL(channel)); 498 if (ret >= 0) 499 ret = fts_write_byte(data->client, FTS_REG_FAN_CONTROL(channel), 500 ret | 0x1); 501 if (ret >= 0) 502 data->valid = false; 503 504 mutex_unlock(&data->update_lock); 505 if (ret < 0) 506 return ret; 507 508 return 0; 509 default: 510 break; 511 } 512 break; 513 default: 514 break; 515 } 516 517 return -EOPNOTSUPP; 518 } 519 520 static const struct hwmon_ops fts_ops = { 521 .is_visible = fts_is_visible, 522 .read = fts_read, 523 .write = fts_write, 524 }; 525 526 static const struct hwmon_channel_info * const fts_info[] = { 527 HWMON_CHANNEL_INFO(chip, HWMON_C_REGISTER_TZ), 528 HWMON_CHANNEL_INFO(temp, 529 HWMON_T_INPUT | HWMON_T_ALARM | HWMON_T_FAULT, 530 HWMON_T_INPUT | HWMON_T_ALARM | HWMON_T_FAULT, 531 HWMON_T_INPUT | HWMON_T_ALARM | HWMON_T_FAULT, 532 HWMON_T_INPUT | HWMON_T_ALARM | HWMON_T_FAULT, 533 HWMON_T_INPUT | HWMON_T_ALARM | HWMON_T_FAULT, 534 HWMON_T_INPUT | HWMON_T_ALARM | HWMON_T_FAULT, 535 HWMON_T_INPUT | HWMON_T_ALARM | HWMON_T_FAULT, 536 HWMON_T_INPUT | HWMON_T_ALARM | HWMON_T_FAULT, 537 HWMON_T_INPUT | HWMON_T_ALARM | HWMON_T_FAULT, 538 HWMON_T_INPUT | HWMON_T_ALARM | HWMON_T_FAULT, 539 HWMON_T_INPUT | HWMON_T_ALARM | HWMON_T_FAULT, 540 HWMON_T_INPUT | HWMON_T_ALARM | HWMON_T_FAULT, 541 HWMON_T_INPUT | HWMON_T_ALARM | HWMON_T_FAULT, 542 HWMON_T_INPUT | HWMON_T_ALARM | HWMON_T_FAULT, 543 HWMON_T_INPUT | HWMON_T_ALARM | HWMON_T_FAULT, 544 HWMON_T_INPUT | HWMON_T_ALARM | HWMON_T_FAULT 545 ), 546 HWMON_CHANNEL_INFO(fan, 547 HWMON_F_INPUT | HWMON_F_ALARM | HWMON_F_FAULT, 548 HWMON_F_INPUT | HWMON_F_ALARM | HWMON_F_FAULT, 549 HWMON_F_INPUT | HWMON_F_ALARM | HWMON_F_FAULT, 550 HWMON_F_INPUT | HWMON_F_ALARM | HWMON_F_FAULT, 551 HWMON_F_INPUT | HWMON_F_ALARM | HWMON_F_FAULT, 552 HWMON_F_INPUT | HWMON_F_ALARM | HWMON_F_FAULT, 553 HWMON_F_INPUT | HWMON_F_ALARM | HWMON_F_FAULT, 554 HWMON_F_INPUT | HWMON_F_ALARM | HWMON_F_FAULT 555 ), 556 HWMON_CHANNEL_INFO(pwm, 557 HWMON_PWM_AUTO_CHANNELS_TEMP, 558 HWMON_PWM_AUTO_CHANNELS_TEMP, 559 HWMON_PWM_AUTO_CHANNELS_TEMP, 560 HWMON_PWM_AUTO_CHANNELS_TEMP, 561 HWMON_PWM_AUTO_CHANNELS_TEMP, 562 HWMON_PWM_AUTO_CHANNELS_TEMP, 563 HWMON_PWM_AUTO_CHANNELS_TEMP, 564 HWMON_PWM_AUTO_CHANNELS_TEMP 565 ), 566 HWMON_CHANNEL_INFO(in, 567 HWMON_I_INPUT, 568 HWMON_I_INPUT, 569 HWMON_I_INPUT, 570 HWMON_I_INPUT 571 ), 572 NULL 573 }; 574 575 static const struct hwmon_chip_info fts_chip_info = { 576 .ops = &fts_ops, 577 .info = fts_info, 578 }; 579 580 /*****************************************************************************/ 581 /* Module initialization / remove functions */ 582 /*****************************************************************************/ 583 static int fts_detect(struct i2c_client *client, 584 struct i2c_board_info *info) 585 { 586 int val; 587 588 /* detection works with revision greater or equal to 0x2b */ 589 val = i2c_smbus_read_byte_data(client, FTS_DEVICE_REVISION_REG); 590 if (val < 0x2b) 591 return -ENODEV; 592 593 /* Device Detect Regs must have 0x17 0x34 and 0x54 */ 594 val = i2c_smbus_read_byte_data(client, FTS_DEVICE_DETECT_REG_1); 595 if (val != 0x17) 596 return -ENODEV; 597 598 val = i2c_smbus_read_byte_data(client, FTS_DEVICE_DETECT_REG_2); 599 if (val != 0x34) 600 return -ENODEV; 601 602 val = i2c_smbus_read_byte_data(client, FTS_DEVICE_DETECT_REG_3); 603 if (val != 0x54) 604 return -ENODEV; 605 606 /* 607 * 0x10 == Baseboard Management Controller, 0x01 == Teutates 608 * Device ID Reg needs to be 0x11 609 */ 610 val = i2c_smbus_read_byte_data(client, FTS_DEVICE_ID_REG); 611 if (val != 0x11) 612 return -ENODEV; 613 614 strscpy(info->type, fts_id[0].name, I2C_NAME_SIZE); 615 info->flags = 0; 616 return 0; 617 } 618 619 static int fts_probe(struct i2c_client *client) 620 { 621 u8 revision; 622 struct fts_data *data; 623 int err; 624 s8 deviceid; 625 struct device *hwmon_dev; 626 627 if (client->addr != 0x73) 628 return -ENODEV; 629 630 /* Baseboard Management Controller check */ 631 deviceid = i2c_smbus_read_byte_data(client, FTS_DEVICE_ID_REG); 632 if (deviceid > 0 && (deviceid & 0xF0) == 0x10) { 633 switch (deviceid & 0x0F) { 634 case 0x01: 635 break; 636 default: 637 dev_dbg(&client->dev, 638 "No Baseboard Management Controller\n"); 639 return -ENODEV; 640 } 641 } else { 642 dev_dbg(&client->dev, "No fujitsu board\n"); 643 return -ENODEV; 644 } 645 646 data = devm_kzalloc(&client->dev, sizeof(struct fts_data), 647 GFP_KERNEL); 648 if (!data) 649 return -ENOMEM; 650 651 mutex_init(&data->update_lock); 652 mutex_init(&data->access_lock); 653 data->client = client; 654 dev_set_drvdata(&client->dev, data); 655 656 err = i2c_smbus_read_byte_data(client, FTS_DEVICE_REVISION_REG); 657 if (err < 0) 658 return err; 659 revision = err; 660 661 hwmon_dev = devm_hwmon_device_register_with_info(&client->dev, "ftsteutates", data, 662 &fts_chip_info, NULL); 663 if (IS_ERR(hwmon_dev)) 664 return PTR_ERR(hwmon_dev); 665 666 err = fts_watchdog_init(data); 667 if (err) 668 return err; 669 670 dev_info(&client->dev, "Detected FTS Teutates chip, revision: %d.%d\n", 671 (revision & 0xF0) >> 4, revision & 0x0F); 672 return 0; 673 } 674 675 /*****************************************************************************/ 676 /* Module Details */ 677 /*****************************************************************************/ 678 static struct i2c_driver fts_driver = { 679 .class = I2C_CLASS_HWMON, 680 .driver = { 681 .name = "ftsteutates", 682 }, 683 .id_table = fts_id, 684 .probe = fts_probe, 685 .detect = fts_detect, 686 .address_list = normal_i2c, 687 }; 688 689 module_i2c_driver(fts_driver); 690 691 MODULE_AUTHOR("Thilo Cestonaro <thilo.cestonaro@ts.fujitsu.com>"); 692 MODULE_DESCRIPTION("FTS Teutates driver"); 693 MODULE_LICENSE("GPL"); 694