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