1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /*************************************************************************** 3 * Copyright (C) 2010-2012 Hans de Goede <hdegoede@redhat.com> * 4 * * 5 ***************************************************************************/ 6 7 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 8 9 #include <linux/bits.h> 10 #include <linux/minmax.h> 11 #include <linux/module.h> 12 #include <linux/pm.h> 13 #include <linux/init.h> 14 #include <linux/regmap.h> 15 #include <linux/slab.h> 16 #include <linux/jiffies.h> 17 #include <linux/platform_device.h> 18 #include <linux/hwmon.h> 19 #include <linux/err.h> 20 #include <linux/mutex.h> 21 #include "sch56xx-common.h" 22 23 #define DRVNAME "sch5627" 24 #define DEVNAME DRVNAME /* We only support one model */ 25 26 #define SCH5627_HWMON_ID 0xa5 27 #define SCH5627_COMPANY_ID 0x5c 28 #define SCH5627_PRIMARY_ID 0xa0 29 30 #define SCH5627_REG_BUILD_CODE 0x39 31 #define SCH5627_REG_BUILD_ID 0x3a 32 #define SCH5627_REG_HWMON_ID 0x3c 33 #define SCH5627_REG_HWMON_REV 0x3d 34 #define SCH5627_REG_COMPANY_ID 0x3e 35 #define SCH5627_REG_PRIMARY_ID 0x3f 36 #define SCH5627_REG_CTRL 0x40 37 38 #define SCH5627_CTRL_START BIT(0) 39 #define SCH5627_CTRL_LOCK BIT(1) 40 #define SCH5627_CTRL_VBAT BIT(4) 41 42 #define SCH5627_NO_TEMPS 8 43 #define SCH5627_NO_FANS 4 44 #define SCH5627_NO_IN 5 45 46 static const u16 SCH5627_REG_TEMP_MSB[SCH5627_NO_TEMPS] = { 47 0x2B, 0x26, 0x27, 0x28, 0x29, 0x2A, 0x180, 0x181 }; 48 static const u16 SCH5627_REG_TEMP_LSN[SCH5627_NO_TEMPS] = { 49 0xE2, 0xE1, 0xE1, 0xE5, 0xE5, 0xE6, 0x182, 0x182 }; 50 static const u16 SCH5627_REG_TEMP_HIGH_NIBBLE[SCH5627_NO_TEMPS] = { 51 0, 0, 1, 1, 0, 0, 0, 1 }; 52 static const u16 SCH5627_REG_TEMP_HIGH[SCH5627_NO_TEMPS] = { 53 0x61, 0x57, 0x59, 0x5B, 0x5D, 0x5F, 0x184, 0x186 }; 54 static const u16 SCH5627_REG_TEMP_ABS[SCH5627_NO_TEMPS] = { 55 0x9B, 0x96, 0x97, 0x98, 0x99, 0x9A, 0x1A8, 0x1A9 }; 56 57 static const u16 SCH5627_REG_FAN[SCH5627_NO_FANS] = { 58 0x2C, 0x2E, 0x30, 0x32 }; 59 static const u16 SCH5627_REG_FAN_MIN[SCH5627_NO_FANS] = { 60 0x62, 0x64, 0x66, 0x68 }; 61 62 static const u16 SCH5627_REG_PWM_MAP[SCH5627_NO_FANS] = { 63 0xA0, 0xA1, 0xA2, 0xA3 }; 64 65 static const u16 SCH5627_REG_IN_MSB[SCH5627_NO_IN] = { 66 0x22, 0x23, 0x24, 0x25, 0x189 }; 67 static const u16 SCH5627_REG_IN_LSN[SCH5627_NO_IN] = { 68 0xE4, 0xE4, 0xE3, 0xE3, 0x18A }; 69 static const u16 SCH5627_REG_IN_HIGH_NIBBLE[SCH5627_NO_IN] = { 70 1, 0, 1, 0, 1 }; 71 static const u16 SCH5627_REG_IN_FACTOR[SCH5627_NO_IN] = { 72 10745, 3660, 9765, 10745, 3660 }; 73 static const char * const SCH5627_IN_LABELS[SCH5627_NO_IN] = { 74 "VCC", "VTT", "VBAT", "VTR", "V_IN" }; 75 76 struct sch5627_data { 77 struct regmap *regmap; 78 unsigned short addr; 79 u8 control; 80 81 struct mutex update_lock; 82 unsigned long last_battery; /* In jiffies */ 83 char temp_valid; /* !=0 if following fields are valid */ 84 char fan_valid; 85 char in_valid; 86 unsigned long temp_last_updated; /* In jiffies */ 87 unsigned long fan_last_updated; 88 unsigned long in_last_updated; 89 u16 temp[SCH5627_NO_TEMPS]; 90 u16 fan[SCH5627_NO_FANS]; 91 u16 in[SCH5627_NO_IN]; 92 }; 93 94 static const struct regmap_range sch5627_tunables_ranges[] = { 95 regmap_reg_range(0x57, 0x57), 96 regmap_reg_range(0x59, 0x59), 97 regmap_reg_range(0x5B, 0x5B), 98 regmap_reg_range(0x5D, 0x5D), 99 regmap_reg_range(0x5F, 0x5F), 100 regmap_reg_range(0x61, 0x69), 101 regmap_reg_range(0x96, 0x9B), 102 regmap_reg_range(0xA0, 0xA3), 103 regmap_reg_range(0x184, 0x184), 104 regmap_reg_range(0x186, 0x186), 105 regmap_reg_range(0x1A8, 0x1A9), 106 }; 107 108 static const struct regmap_access_table sch5627_tunables_table = { 109 .yes_ranges = sch5627_tunables_ranges, 110 .n_yes_ranges = ARRAY_SIZE(sch5627_tunables_ranges), 111 }; 112 113 static const struct regmap_config sch5627_regmap_config = { 114 .reg_bits = 16, 115 .val_bits = 8, 116 .wr_table = &sch5627_tunables_table, 117 .rd_table = &sch5627_tunables_table, 118 .cache_type = REGCACHE_MAPLE, 119 .use_single_read = true, 120 .use_single_write = true, 121 .can_sleep = true, 122 }; 123 124 static int sch5627_update_temp(struct sch5627_data *data) 125 { 126 int ret = 0; 127 int i, val; 128 129 mutex_lock(&data->update_lock); 130 131 /* Cache the values for 1 second */ 132 if (time_after(jiffies, data->temp_last_updated + HZ) || !data->temp_valid) { 133 for (i = 0; i < SCH5627_NO_TEMPS; i++) { 134 val = sch56xx_read_virtual_reg12(data->addr, SCH5627_REG_TEMP_MSB[i], 135 SCH5627_REG_TEMP_LSN[i], 136 SCH5627_REG_TEMP_HIGH_NIBBLE[i]); 137 if (unlikely(val < 0)) { 138 ret = val; 139 goto abort; 140 } 141 data->temp[i] = val; 142 } 143 data->temp_last_updated = jiffies; 144 data->temp_valid = 1; 145 } 146 abort: 147 mutex_unlock(&data->update_lock); 148 return ret; 149 } 150 151 static int sch5627_update_fan(struct sch5627_data *data) 152 { 153 int ret = 0; 154 int i, val; 155 156 mutex_lock(&data->update_lock); 157 158 /* Cache the values for 1 second */ 159 if (time_after(jiffies, data->fan_last_updated + HZ) || !data->fan_valid) { 160 for (i = 0; i < SCH5627_NO_FANS; i++) { 161 val = sch56xx_read_virtual_reg16(data->addr, SCH5627_REG_FAN[i]); 162 if (unlikely(val < 0)) { 163 ret = val; 164 goto abort; 165 } 166 data->fan[i] = val; 167 } 168 data->fan_last_updated = jiffies; 169 data->fan_valid = 1; 170 } 171 abort: 172 mutex_unlock(&data->update_lock); 173 return ret; 174 } 175 176 static int sch5627_update_in(struct sch5627_data *data) 177 { 178 int ret = 0; 179 int i, val; 180 181 mutex_lock(&data->update_lock); 182 183 /* Trigger a Vbat voltage measurement every 5 minutes */ 184 if (time_after(jiffies, data->last_battery + 300 * HZ)) { 185 sch56xx_write_virtual_reg(data->addr, SCH5627_REG_CTRL, 186 data->control | SCH5627_CTRL_VBAT); 187 data->last_battery = jiffies; 188 } 189 190 /* Cache the values for 1 second */ 191 if (time_after(jiffies, data->in_last_updated + HZ) || !data->in_valid) { 192 for (i = 0; i < SCH5627_NO_IN; i++) { 193 val = sch56xx_read_virtual_reg12(data->addr, SCH5627_REG_IN_MSB[i], 194 SCH5627_REG_IN_LSN[i], 195 SCH5627_REG_IN_HIGH_NIBBLE[i]); 196 if (unlikely(val < 0)) { 197 ret = val; 198 goto abort; 199 } 200 data->in[i] = val; 201 } 202 data->in_last_updated = jiffies; 203 data->in_valid = 1; 204 } 205 abort: 206 mutex_unlock(&data->update_lock); 207 return ret; 208 } 209 210 static int reg_to_temp(u16 reg) 211 { 212 return (reg * 625) / 10 - 64000; 213 } 214 215 static int reg_to_temp_limit(u8 reg) 216 { 217 return (reg - 64) * 1000; 218 } 219 220 static int reg_to_rpm(u16 reg) 221 { 222 if (reg == 0) 223 return -EIO; 224 if (reg == 0xffff) 225 return 0; 226 227 return 5400540 / reg; 228 } 229 230 static u8 sch5627_temp_limit_to_reg(long value) 231 { 232 long limit = (value / 1000) + 64; 233 234 return clamp_val(limit, 0, U8_MAX); 235 } 236 237 static u16 sch5627_rpm_to_reg(long value) 238 { 239 long pulses; 240 241 if (value <= 0) 242 return U16_MAX - 1; 243 244 pulses = 5400540 / value; 245 246 return clamp_val(pulses, 1, U16_MAX - 1); 247 } 248 249 static umode_t sch5627_is_visible(const void *drvdata, enum hwmon_sensor_types type, u32 attr, 250 int channel) 251 { 252 const struct sch5627_data *data = drvdata; 253 254 /* Once the lock bit is set, the virtual registers become read-only 255 * until the next power cycle. 256 */ 257 if (data->control & SCH5627_CTRL_LOCK) 258 return 0444; 259 260 switch (type) { 261 case hwmon_temp: 262 switch (attr) { 263 case hwmon_temp_max: 264 case hwmon_temp_crit: 265 return 0644; 266 default: 267 break; 268 } 269 break; 270 case hwmon_fan: 271 switch (attr) { 272 case hwmon_fan_min: 273 return 0644; 274 default: 275 break; 276 } 277 break; 278 case hwmon_pwm: 279 switch (attr) { 280 case hwmon_pwm_auto_channels_temp: 281 return 0644; 282 default: 283 break; 284 } 285 break; 286 default: 287 break; 288 } 289 290 return 0444; 291 } 292 293 static int sch5627_read(struct device *dev, enum hwmon_sensor_types type, u32 attr, int channel, 294 long *val) 295 { 296 struct sch5627_data *data = dev_get_drvdata(dev); 297 int ret, value; 298 299 switch (type) { 300 case hwmon_temp: 301 switch (attr) { 302 case hwmon_temp_input: 303 ret = sch5627_update_temp(data); 304 if (ret < 0) 305 return ret; 306 307 *val = reg_to_temp(data->temp[channel]); 308 return 0; 309 case hwmon_temp_max: 310 ret = regmap_read(data->regmap, SCH5627_REG_TEMP_ABS[channel], &value); 311 if (ret < 0) 312 return ret; 313 314 *val = reg_to_temp_limit((u8)value); 315 return 0; 316 case hwmon_temp_crit: 317 ret = regmap_read(data->regmap, SCH5627_REG_TEMP_HIGH[channel], &value); 318 if (ret < 0) 319 return ret; 320 321 *val = reg_to_temp_limit((u8)value); 322 return 0; 323 case hwmon_temp_fault: 324 ret = sch5627_update_temp(data); 325 if (ret < 0) 326 return ret; 327 328 *val = (data->temp[channel] == 0); 329 return 0; 330 default: 331 break; 332 } 333 break; 334 case hwmon_fan: 335 switch (attr) { 336 case hwmon_fan_input: 337 ret = sch5627_update_fan(data); 338 if (ret < 0) 339 return ret; 340 341 ret = reg_to_rpm(data->fan[channel]); 342 if (ret < 0) 343 return ret; 344 345 *val = ret; 346 return 0; 347 case hwmon_fan_min: 348 ret = sch56xx_regmap_read16(data->regmap, SCH5627_REG_FAN_MIN[channel], 349 &value); 350 if (ret < 0) 351 return ret; 352 353 ret = reg_to_rpm((u16)value); 354 if (ret < 0) 355 return ret; 356 357 *val = ret; 358 return 0; 359 case hwmon_fan_fault: 360 ret = sch5627_update_fan(data); 361 if (ret < 0) 362 return ret; 363 364 *val = (data->fan[channel] == 0xffff); 365 return 0; 366 default: 367 break; 368 } 369 break; 370 case hwmon_pwm: 371 switch (attr) { 372 case hwmon_pwm_auto_channels_temp: 373 ret = regmap_read(data->regmap, SCH5627_REG_PWM_MAP[channel], &value); 374 if (ret < 0) 375 return ret; 376 377 *val = value; 378 return 0; 379 default: 380 break; 381 } 382 break; 383 case hwmon_in: 384 ret = sch5627_update_in(data); 385 if (ret < 0) 386 return ret; 387 switch (attr) { 388 case hwmon_in_input: 389 *val = DIV_ROUND_CLOSEST(data->in[channel] * SCH5627_REG_IN_FACTOR[channel], 390 10000); 391 return 0; 392 default: 393 break; 394 } 395 break; 396 default: 397 break; 398 } 399 400 return -EOPNOTSUPP; 401 } 402 403 static int sch5627_read_string(struct device *dev, enum hwmon_sensor_types type, u32 attr, 404 int channel, const char **str) 405 { 406 switch (type) { 407 case hwmon_in: 408 switch (attr) { 409 case hwmon_in_label: 410 *str = SCH5627_IN_LABELS[channel]; 411 return 0; 412 default: 413 break; 414 } 415 break; 416 default: 417 break; 418 } 419 420 return -EOPNOTSUPP; 421 } 422 423 static int sch5627_write(struct device *dev, enum hwmon_sensor_types type, u32 attr, int channel, 424 long val) 425 { 426 struct sch5627_data *data = dev_get_drvdata(dev); 427 u16 fan; 428 u8 temp; 429 430 switch (type) { 431 case hwmon_temp: 432 temp = sch5627_temp_limit_to_reg(val); 433 434 switch (attr) { 435 case hwmon_temp_max: 436 return regmap_write(data->regmap, SCH5627_REG_TEMP_ABS[channel], temp); 437 case hwmon_temp_crit: 438 return regmap_write(data->regmap, SCH5627_REG_TEMP_HIGH[channel], temp); 439 default: 440 break; 441 } 442 break; 443 case hwmon_fan: 444 switch (attr) { 445 case hwmon_fan_min: 446 fan = sch5627_rpm_to_reg(val); 447 448 return sch56xx_regmap_write16(data->regmap, SCH5627_REG_FAN_MIN[channel], 449 fan); 450 default: 451 break; 452 } 453 break; 454 case hwmon_pwm: 455 switch (attr) { 456 case hwmon_pwm_auto_channels_temp: 457 /* registers are 8 bit wide */ 458 if (val > U8_MAX || val < 0) 459 return -EINVAL; 460 461 return regmap_write(data->regmap, SCH5627_REG_PWM_MAP[channel], val); 462 default: 463 break; 464 } 465 break; 466 default: 467 break; 468 } 469 470 return -EOPNOTSUPP; 471 } 472 473 static const struct hwmon_ops sch5627_ops = { 474 .is_visible = sch5627_is_visible, 475 .read = sch5627_read, 476 .read_string = sch5627_read_string, 477 .write = sch5627_write, 478 }; 479 480 static const struct hwmon_channel_info * const sch5627_info[] = { 481 HWMON_CHANNEL_INFO(chip, HWMON_C_REGISTER_TZ), 482 HWMON_CHANNEL_INFO(temp, 483 HWMON_T_INPUT | HWMON_T_MAX | HWMON_T_CRIT | HWMON_T_FAULT, 484 HWMON_T_INPUT | HWMON_T_MAX | HWMON_T_CRIT | HWMON_T_FAULT, 485 HWMON_T_INPUT | HWMON_T_MAX | HWMON_T_CRIT | HWMON_T_FAULT, 486 HWMON_T_INPUT | HWMON_T_MAX | HWMON_T_CRIT | HWMON_T_FAULT, 487 HWMON_T_INPUT | HWMON_T_MAX | HWMON_T_CRIT | HWMON_T_FAULT, 488 HWMON_T_INPUT | HWMON_T_MAX | HWMON_T_CRIT | HWMON_T_FAULT, 489 HWMON_T_INPUT | HWMON_T_MAX | HWMON_T_CRIT | HWMON_T_FAULT, 490 HWMON_T_INPUT | HWMON_T_MAX | HWMON_T_CRIT | HWMON_T_FAULT 491 ), 492 HWMON_CHANNEL_INFO(fan, 493 HWMON_F_INPUT | HWMON_F_MIN | HWMON_F_FAULT, 494 HWMON_F_INPUT | HWMON_F_MIN | HWMON_F_FAULT, 495 HWMON_F_INPUT | HWMON_F_MIN | HWMON_F_FAULT, 496 HWMON_F_INPUT | HWMON_F_MIN | HWMON_F_FAULT 497 ), 498 HWMON_CHANNEL_INFO(pwm, 499 HWMON_PWM_AUTO_CHANNELS_TEMP, 500 HWMON_PWM_AUTO_CHANNELS_TEMP, 501 HWMON_PWM_AUTO_CHANNELS_TEMP, 502 HWMON_PWM_AUTO_CHANNELS_TEMP 503 ), 504 HWMON_CHANNEL_INFO(in, 505 HWMON_I_INPUT | HWMON_I_LABEL, 506 HWMON_I_INPUT | HWMON_I_LABEL, 507 HWMON_I_INPUT | HWMON_I_LABEL, 508 HWMON_I_INPUT | HWMON_I_LABEL, 509 HWMON_I_INPUT 510 ), 511 NULL 512 }; 513 514 static const struct hwmon_chip_info sch5627_chip_info = { 515 .ops = &sch5627_ops, 516 .info = sch5627_info, 517 }; 518 519 static int sch5627_probe(struct platform_device *pdev) 520 { 521 struct sch5627_data *data; 522 struct device *hwmon_dev; 523 int build_code, build_id, hwmon_rev, val; 524 525 data = devm_kzalloc(&pdev->dev, sizeof(struct sch5627_data), 526 GFP_KERNEL); 527 if (!data) 528 return -ENOMEM; 529 530 data->addr = platform_get_resource(pdev, IORESOURCE_IO, 0)->start; 531 mutex_init(&data->update_lock); 532 platform_set_drvdata(pdev, data); 533 534 val = sch56xx_read_virtual_reg(data->addr, SCH5627_REG_HWMON_ID); 535 if (val < 0) 536 return val; 537 538 if (val != SCH5627_HWMON_ID) { 539 pr_err("invalid %s id: 0x%02X (expected 0x%02X)\n", "hwmon", 540 val, SCH5627_HWMON_ID); 541 return -ENODEV; 542 } 543 544 val = sch56xx_read_virtual_reg(data->addr, SCH5627_REG_COMPANY_ID); 545 if (val < 0) 546 return val; 547 548 if (val != SCH5627_COMPANY_ID) { 549 pr_err("invalid %s id: 0x%02X (expected 0x%02X)\n", "company", 550 val, SCH5627_COMPANY_ID); 551 return -ENODEV; 552 } 553 554 val = sch56xx_read_virtual_reg(data->addr, SCH5627_REG_PRIMARY_ID); 555 if (val < 0) 556 return val; 557 558 if (val != SCH5627_PRIMARY_ID) { 559 pr_err("invalid %s id: 0x%02X (expected 0x%02X)\n", "primary", 560 val, SCH5627_PRIMARY_ID); 561 return -ENODEV; 562 } 563 564 build_code = sch56xx_read_virtual_reg(data->addr, 565 SCH5627_REG_BUILD_CODE); 566 if (build_code < 0) 567 return build_code; 568 569 build_id = sch56xx_read_virtual_reg16(data->addr, 570 SCH5627_REG_BUILD_ID); 571 if (build_id < 0) 572 return build_id; 573 574 hwmon_rev = sch56xx_read_virtual_reg(data->addr, 575 SCH5627_REG_HWMON_REV); 576 if (hwmon_rev < 0) 577 return hwmon_rev; 578 579 val = sch56xx_read_virtual_reg(data->addr, SCH5627_REG_CTRL); 580 if (val < 0) 581 return val; 582 583 data->control = val; 584 if (!(data->control & SCH5627_CTRL_START)) { 585 pr_err("hardware monitoring not enabled\n"); 586 return -ENODEV; 587 } 588 589 data->regmap = devm_regmap_init_sch56xx(&pdev->dev, &data->update_lock, data->addr, 590 &sch5627_regmap_config); 591 if (IS_ERR(data->regmap)) 592 return PTR_ERR(data->regmap); 593 594 /* Trigger a Vbat voltage measurement, so that we get a valid reading 595 the first time we read Vbat */ 596 sch56xx_write_virtual_reg(data->addr, SCH5627_REG_CTRL, data->control | SCH5627_CTRL_VBAT); 597 data->last_battery = jiffies; 598 599 pr_info("found %s chip at %#hx\n", DEVNAME, data->addr); 600 pr_info("firmware build: code 0x%02X, id 0x%04X, hwmon: rev 0x%02X\n", 601 build_code, build_id, hwmon_rev); 602 603 hwmon_dev = devm_hwmon_device_register_with_info(&pdev->dev, DEVNAME, data, 604 &sch5627_chip_info, NULL); 605 if (IS_ERR(hwmon_dev)) 606 return PTR_ERR(hwmon_dev); 607 608 /* Note failing to register the watchdog is not a fatal error */ 609 sch56xx_watchdog_register(&pdev->dev, data->addr, 610 (build_code << 24) | (build_id << 8) | hwmon_rev, 611 &data->update_lock, 1); 612 613 return 0; 614 } 615 616 static int sch5627_suspend(struct device *dev) 617 { 618 struct sch5627_data *data = dev_get_drvdata(dev); 619 620 regcache_cache_only(data->regmap, true); 621 regcache_mark_dirty(data->regmap); 622 623 return 0; 624 } 625 626 static int sch5627_resume(struct device *dev) 627 { 628 struct sch5627_data *data = dev_get_drvdata(dev); 629 630 regcache_cache_only(data->regmap, false); 631 /* We must not access the virtual registers when the lock bit is set */ 632 if (data->control & SCH5627_CTRL_LOCK) 633 return regcache_drop_region(data->regmap, 0, U16_MAX); 634 635 return regcache_sync(data->regmap); 636 } 637 638 static DEFINE_SIMPLE_DEV_PM_OPS(sch5627_dev_pm_ops, sch5627_suspend, sch5627_resume); 639 640 static const struct platform_device_id sch5627_device_id[] = { 641 { 642 .name = "sch5627", 643 }, 644 { } 645 }; 646 MODULE_DEVICE_TABLE(platform, sch5627_device_id); 647 648 static struct platform_driver sch5627_driver = { 649 .driver = { 650 .name = DRVNAME, 651 .pm = pm_sleep_ptr(&sch5627_dev_pm_ops), 652 }, 653 .probe = sch5627_probe, 654 .id_table = sch5627_device_id, 655 }; 656 657 module_platform_driver(sch5627_driver); 658 659 MODULE_DESCRIPTION("SMSC SCH5627 Hardware Monitoring Driver"); 660 MODULE_AUTHOR("Hans de Goede <hdegoede@redhat.com>"); 661 MODULE_LICENSE("GPL"); 662