1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * Linux driver for WMI sensor information on Dell notebooks. 4 * 5 * Copyright (C) 2022 Armin Wolf <W_Armin@gmx.de> 6 */ 7 8 #define pr_format(fmt) KBUILD_MODNAME ": " fmt 9 10 #include <linux/acpi.h> 11 #include <linux/bitfield.h> 12 #include <linux/debugfs.h> 13 #include <linux/device.h> 14 #include <linux/device/driver.h> 15 #include <linux/dev_printk.h> 16 #include <linux/errno.h> 17 #include <linux/kconfig.h> 18 #include <linux/kernel.h> 19 #include <linux/hwmon.h> 20 #include <linux/kstrtox.h> 21 #include <linux/math64.h> 22 #include <linux/module.h> 23 #include <linux/mutex.h> 24 #include <linux/limits.h> 25 #include <linux/pm.h> 26 #include <linux/power_supply.h> 27 #include <linux/printk.h> 28 #include <linux/seq_file.h> 29 #include <linux/sysfs.h> 30 #include <linux/types.h> 31 #include <linux/wmi.h> 32 33 #include <acpi/battery.h> 34 35 #include <linux/unaligned.h> 36 37 #define DRIVER_NAME "dell-wmi-ddv" 38 39 #define DELL_DDV_SUPPORTED_VERSION_MIN 2 40 #define DELL_DDV_SUPPORTED_VERSION_MAX 3 41 #define DELL_DDV_GUID "8A42EA14-4F2A-FD45-6422-0087F7A7E608" 42 43 /* Battery indices 1, 2 and 3 */ 44 #define DELL_DDV_NUM_BATTERIES 3 45 46 #define SBS_MANUFACTURE_YEAR_MASK GENMASK(15, 9) 47 #define SBS_MANUFACTURE_MONTH_MASK GENMASK(8, 5) 48 #define SBS_MANUFACTURE_DAY_MASK GENMASK(4, 0) 49 50 #define MA_FAILURE_MODE_MASK GENMASK(11, 8) 51 #define MA_FAILURE_MODE_PERMANENT 0x9 52 #define MA_FAILURE_MODE_OVERHEAT 0xA 53 #define MA_FAILURE_MODE_OVERCURRENT 0xB 54 55 #define MA_PERMANENT_FAILURE_CODE_MASK GENMASK(13, 12) 56 #define MA_PERMANENT_FAILURE_FUSE_BLOWN 0x0 57 #define MA_PERMANENT_FAILURE_CELL_IMBALANCE 0x1 58 #define MA_PERMANENT_FAILURE_OVERVOLTAGE 0x2 59 #define MA_PERMANENT_FAILURE_FET_FAILURE 0x3 60 61 #define MA_OVERHEAT_FAILURE_CODE_MASK GENMASK(15, 12) 62 #define MA_OVERHEAT_FAILURE_START 0x5 63 #define MA_OVERHEAT_FAILURE_CHARGING 0x7 64 #define MA_OVERHEAT_FAILURE_DISCHARGING 0x8 65 66 #define MA_OVERCURRENT_FAILURE_CODE_MASK GENMASK(15, 12) 67 #define MA_OVERCURRENT_FAILURE_CHARGING 0x6 68 #define MA_OVERCURRENT_FAILURE_DISCHARGING 0xB 69 70 #define DELL_EPPID_LENGTH 20 71 #define DELL_EPPID_EXT_LENGTH 23 72 73 static bool force; 74 module_param_unsafe(force, bool, 0); 75 MODULE_PARM_DESC(force, "Force loading without checking for supported WMI interface versions"); 76 77 enum dell_ddv_method { 78 DELL_DDV_BATTERY_DESIGN_CAPACITY = 0x01, 79 DELL_DDV_BATTERY_FULL_CHARGE_CAPACITY = 0x02, 80 DELL_DDV_BATTERY_MANUFACTURE_NAME = 0x03, 81 DELL_DDV_BATTERY_MANUFACTURE_DATE = 0x04, 82 DELL_DDV_BATTERY_SERIAL_NUMBER = 0x05, 83 DELL_DDV_BATTERY_CHEMISTRY_VALUE = 0x06, 84 DELL_DDV_BATTERY_TEMPERATURE = 0x07, 85 DELL_DDV_BATTERY_CURRENT = 0x08, 86 DELL_DDV_BATTERY_VOLTAGE = 0x09, 87 DELL_DDV_BATTERY_MANUFACTURER_ACCESS = 0x0A, 88 DELL_DDV_BATTERY_RELATIVE_CHARGE_STATE = 0x0B, 89 DELL_DDV_BATTERY_CYCLE_COUNT = 0x0C, 90 DELL_DDV_BATTERY_EPPID = 0x0D, 91 DELL_DDV_BATTERY_RAW_ANALYTICS_START = 0x0E, 92 DELL_DDV_BATTERY_RAW_ANALYTICS = 0x0F, 93 DELL_DDV_BATTERY_DESIGN_VOLTAGE = 0x10, 94 DELL_DDV_BATTERY_RAW_ANALYTICS_A_BLOCK = 0x11, /* version 3 */ 95 96 DELL_DDV_INTERFACE_VERSION = 0x12, 97 98 DELL_DDV_FAN_SENSOR_INFORMATION = 0x20, 99 DELL_DDV_THERMAL_SENSOR_INFORMATION = 0x22, 100 }; 101 102 struct fan_sensor_entry { 103 u8 type; 104 __le16 rpm; 105 } __packed; 106 107 struct thermal_sensor_entry { 108 u8 type; 109 s8 now; 110 s8 min; 111 s8 max; 112 u8 unknown; 113 } __packed; 114 115 struct combined_channel_info { 116 struct hwmon_channel_info info; 117 u32 config[]; 118 }; 119 120 struct combined_chip_info { 121 struct hwmon_chip_info chip; 122 const struct hwmon_channel_info *info[]; 123 }; 124 125 struct dell_wmi_ddv_sensors { 126 bool active; 127 struct mutex lock; /* protect caching */ 128 unsigned long timestamp; 129 union acpi_object *obj; 130 u64 entries; 131 }; 132 133 struct dell_wmi_ddv_data { 134 struct acpi_battery_hook hook; 135 struct device_attribute eppid_attr; 136 struct mutex translation_cache_lock; /* Protects the translation cache */ 137 struct power_supply *translation_cache[DELL_DDV_NUM_BATTERIES]; 138 struct dell_wmi_ddv_sensors fans; 139 struct dell_wmi_ddv_sensors temps; 140 struct wmi_device *wdev; 141 }; 142 143 static const char * const fan_labels[] = { 144 "CPU Fan", 145 "Chassis Motherboard Fan", 146 "Video Fan", 147 "Power Supply Fan", 148 "Chipset Fan", 149 "Memory Fan", 150 "PCI Fan", 151 "HDD Fan", 152 }; 153 154 static const char * const fan_dock_labels[] = { 155 "Docking Chassis/Motherboard Fan", 156 "Docking Video Fan", 157 "Docking Power Supply Fan", 158 "Docking Chipset Fan", 159 }; 160 161 static int dell_wmi_ddv_query_type(struct wmi_device *wdev, enum dell_ddv_method method, u32 arg, 162 union acpi_object **result, acpi_object_type type) 163 { 164 struct acpi_buffer out = { ACPI_ALLOCATE_BUFFER, NULL }; 165 const struct acpi_buffer in = { 166 .length = sizeof(arg), 167 .pointer = &arg, 168 }; 169 union acpi_object *obj; 170 acpi_status ret; 171 172 ret = wmidev_evaluate_method(wdev, 0x0, method, &in, &out); 173 if (ACPI_FAILURE(ret)) 174 return -EIO; 175 176 obj = out.pointer; 177 if (!obj) 178 return -ENODATA; 179 180 if (obj->type != type) { 181 kfree(obj); 182 return -ENOMSG; 183 } 184 185 *result = obj; 186 187 return 0; 188 } 189 190 static int dell_wmi_ddv_query_integer(struct wmi_device *wdev, enum dell_ddv_method method, 191 u32 arg, u32 *res) 192 { 193 union acpi_object *obj; 194 int ret; 195 196 ret = dell_wmi_ddv_query_type(wdev, method, arg, &obj, ACPI_TYPE_INTEGER); 197 if (ret < 0) 198 return ret; 199 200 if (obj->integer.value <= U32_MAX) 201 *res = (u32)obj->integer.value; 202 else 203 ret = -ERANGE; 204 205 kfree(obj); 206 207 return ret; 208 } 209 210 static int dell_wmi_ddv_query_buffer(struct wmi_device *wdev, enum dell_ddv_method method, 211 u32 arg, union acpi_object **result) 212 { 213 union acpi_object *obj; 214 u64 buffer_size; 215 int ret; 216 217 ret = dell_wmi_ddv_query_type(wdev, method, arg, &obj, ACPI_TYPE_PACKAGE); 218 if (ret < 0) 219 return ret; 220 221 if (obj->package.count != 2 || 222 obj->package.elements[0].type != ACPI_TYPE_INTEGER || 223 obj->package.elements[1].type != ACPI_TYPE_BUFFER) { 224 ret = -ENOMSG; 225 226 goto err_free; 227 } 228 229 buffer_size = obj->package.elements[0].integer.value; 230 231 if (!buffer_size) { 232 ret = -ENODATA; 233 234 goto err_free; 235 } 236 237 if (buffer_size > obj->package.elements[1].buffer.length) { 238 dev_warn(&wdev->dev, 239 FW_WARN "WMI buffer size (%llu) exceeds ACPI buffer size (%d)\n", 240 buffer_size, obj->package.elements[1].buffer.length); 241 ret = -EMSGSIZE; 242 243 goto err_free; 244 } 245 246 *result = obj; 247 248 return 0; 249 250 err_free: 251 kfree(obj); 252 253 return ret; 254 } 255 256 static int dell_wmi_ddv_query_string(struct wmi_device *wdev, enum dell_ddv_method method, 257 u32 arg, union acpi_object **result) 258 { 259 return dell_wmi_ddv_query_type(wdev, method, arg, result, ACPI_TYPE_STRING); 260 } 261 262 /* 263 * Needs to be called with lock held, except during initialization. 264 */ 265 static int dell_wmi_ddv_update_sensors(struct wmi_device *wdev, enum dell_ddv_method method, 266 struct dell_wmi_ddv_sensors *sensors, size_t entry_size) 267 { 268 u64 buffer_size, rem, entries; 269 union acpi_object *obj; 270 u8 *buffer; 271 int ret; 272 273 if (sensors->obj) { 274 if (time_before(jiffies, sensors->timestamp + HZ)) 275 return 0; 276 277 kfree(sensors->obj); 278 sensors->obj = NULL; 279 } 280 281 ret = dell_wmi_ddv_query_buffer(wdev, method, 0, &obj); 282 if (ret < 0) 283 return ret; 284 285 /* buffer format sanity check */ 286 buffer_size = obj->package.elements[0].integer.value; 287 buffer = obj->package.elements[1].buffer.pointer; 288 entries = div64_u64_rem(buffer_size, entry_size, &rem); 289 if (rem != 1 || buffer[buffer_size - 1] != 0xff) { 290 ret = -ENOMSG; 291 goto err_free; 292 } 293 294 if (!entries) { 295 ret = -ENODATA; 296 goto err_free; 297 } 298 299 sensors->obj = obj; 300 sensors->entries = entries; 301 sensors->timestamp = jiffies; 302 303 return 0; 304 305 err_free: 306 kfree(obj); 307 308 return ret; 309 } 310 311 static umode_t dell_wmi_ddv_is_visible(const void *drvdata, enum hwmon_sensor_types type, u32 attr, 312 int channel) 313 { 314 return 0444; 315 } 316 317 static int dell_wmi_ddv_fan_read_channel(struct dell_wmi_ddv_data *data, u32 attr, int channel, 318 long *val) 319 { 320 struct fan_sensor_entry *entry; 321 int ret; 322 323 ret = dell_wmi_ddv_update_sensors(data->wdev, DELL_DDV_FAN_SENSOR_INFORMATION, 324 &data->fans, sizeof(*entry)); 325 if (ret < 0) 326 return ret; 327 328 if (channel >= data->fans.entries) 329 return -ENXIO; 330 331 entry = (struct fan_sensor_entry *)data->fans.obj->package.elements[1].buffer.pointer; 332 switch (attr) { 333 case hwmon_fan_input: 334 *val = get_unaligned_le16(&entry[channel].rpm); 335 return 0; 336 default: 337 break; 338 } 339 340 return -EOPNOTSUPP; 341 } 342 343 static int dell_wmi_ddv_temp_read_channel(struct dell_wmi_ddv_data *data, u32 attr, int channel, 344 long *val) 345 { 346 struct thermal_sensor_entry *entry; 347 int ret; 348 349 ret = dell_wmi_ddv_update_sensors(data->wdev, DELL_DDV_THERMAL_SENSOR_INFORMATION, 350 &data->temps, sizeof(*entry)); 351 if (ret < 0) 352 return ret; 353 354 if (channel >= data->temps.entries) 355 return -ENXIO; 356 357 entry = (struct thermal_sensor_entry *)data->temps.obj->package.elements[1].buffer.pointer; 358 switch (attr) { 359 case hwmon_temp_input: 360 *val = entry[channel].now * 1000; 361 return 0; 362 case hwmon_temp_min: 363 *val = entry[channel].min * 1000; 364 return 0; 365 case hwmon_temp_max: 366 *val = entry[channel].max * 1000; 367 return 0; 368 default: 369 break; 370 } 371 372 return -EOPNOTSUPP; 373 } 374 375 static int dell_wmi_ddv_read(struct device *dev, enum hwmon_sensor_types type, u32 attr, 376 int channel, long *val) 377 { 378 struct dell_wmi_ddv_data *data = dev_get_drvdata(dev); 379 int ret; 380 381 switch (type) { 382 case hwmon_fan: 383 mutex_lock(&data->fans.lock); 384 ret = dell_wmi_ddv_fan_read_channel(data, attr, channel, val); 385 mutex_unlock(&data->fans.lock); 386 return ret; 387 case hwmon_temp: 388 mutex_lock(&data->temps.lock); 389 ret = dell_wmi_ddv_temp_read_channel(data, attr, channel, val); 390 mutex_unlock(&data->temps.lock); 391 return ret; 392 default: 393 break; 394 } 395 396 return -EOPNOTSUPP; 397 } 398 399 static int dell_wmi_ddv_fan_read_string(struct dell_wmi_ddv_data *data, int channel, 400 const char **str) 401 { 402 struct fan_sensor_entry *entry; 403 int ret; 404 u8 type; 405 406 ret = dell_wmi_ddv_update_sensors(data->wdev, DELL_DDV_FAN_SENSOR_INFORMATION, 407 &data->fans, sizeof(*entry)); 408 if (ret < 0) 409 return ret; 410 411 if (channel >= data->fans.entries) 412 return -ENXIO; 413 414 entry = (struct fan_sensor_entry *)data->fans.obj->package.elements[1].buffer.pointer; 415 type = entry[channel].type; 416 switch (type) { 417 case 0x00 ... 0x07: 418 *str = fan_labels[type]; 419 break; 420 case 0x11 ... 0x14: 421 *str = fan_dock_labels[type - 0x11]; 422 break; 423 default: 424 *str = "Unknown Fan"; 425 break; 426 } 427 428 return 0; 429 } 430 431 static int dell_wmi_ddv_temp_read_string(struct dell_wmi_ddv_data *data, int channel, 432 const char **str) 433 { 434 struct thermal_sensor_entry *entry; 435 int ret; 436 437 ret = dell_wmi_ddv_update_sensors(data->wdev, DELL_DDV_THERMAL_SENSOR_INFORMATION, 438 &data->temps, sizeof(*entry)); 439 if (ret < 0) 440 return ret; 441 442 if (channel >= data->temps.entries) 443 return -ENXIO; 444 445 entry = (struct thermal_sensor_entry *)data->temps.obj->package.elements[1].buffer.pointer; 446 switch (entry[channel].type) { 447 case 0x00: 448 *str = "CPU"; 449 break; 450 case 0x11: 451 *str = "Video"; 452 break; 453 case 0x22: 454 *str = "Memory"; /* sometimes called DIMM */ 455 break; 456 case 0x33: 457 *str = "Other"; 458 break; 459 case 0x44: 460 *str = "Ambient"; /* sometimes called SKIN */ 461 break; 462 case 0x52: 463 *str = "SODIMM"; 464 break; 465 case 0x55: 466 *str = "HDD"; 467 break; 468 case 0x62: 469 *str = "SODIMM 2"; 470 break; 471 case 0x73: 472 *str = "NB"; 473 break; 474 case 0x83: 475 *str = "Charger"; 476 break; 477 case 0xbb: 478 *str = "Memory 3"; 479 break; 480 default: 481 *str = "Unknown"; 482 break; 483 } 484 485 return 0; 486 } 487 488 static int dell_wmi_ddv_read_string(struct device *dev, enum hwmon_sensor_types type, u32 attr, 489 int channel, const char **str) 490 { 491 struct dell_wmi_ddv_data *data = dev_get_drvdata(dev); 492 int ret; 493 494 switch (type) { 495 case hwmon_fan: 496 switch (attr) { 497 case hwmon_fan_label: 498 mutex_lock(&data->fans.lock); 499 ret = dell_wmi_ddv_fan_read_string(data, channel, str); 500 mutex_unlock(&data->fans.lock); 501 return ret; 502 default: 503 break; 504 } 505 break; 506 case hwmon_temp: 507 switch (attr) { 508 case hwmon_temp_label: 509 mutex_lock(&data->temps.lock); 510 ret = dell_wmi_ddv_temp_read_string(data, channel, str); 511 mutex_unlock(&data->temps.lock); 512 return ret; 513 default: 514 break; 515 } 516 break; 517 default: 518 break; 519 } 520 521 return -EOPNOTSUPP; 522 } 523 524 static const struct hwmon_ops dell_wmi_ddv_ops = { 525 .is_visible = dell_wmi_ddv_is_visible, 526 .read = dell_wmi_ddv_read, 527 .read_string = dell_wmi_ddv_read_string, 528 }; 529 530 static struct hwmon_channel_info *dell_wmi_ddv_channel_create(struct device *dev, u64 count, 531 enum hwmon_sensor_types type, 532 u32 config) 533 { 534 struct combined_channel_info *cinfo; 535 int i; 536 537 cinfo = devm_kzalloc(dev, struct_size(cinfo, config, count + 1), GFP_KERNEL); 538 if (!cinfo) 539 return ERR_PTR(-ENOMEM); 540 541 cinfo->info.type = type; 542 cinfo->info.config = cinfo->config; 543 544 for (i = 0; i < count; i++) 545 cinfo->config[i] = config; 546 547 return &cinfo->info; 548 } 549 550 static void dell_wmi_ddv_hwmon_cache_invalidate(struct dell_wmi_ddv_sensors *sensors) 551 { 552 if (!sensors->active) 553 return; 554 555 mutex_lock(&sensors->lock); 556 kfree(sensors->obj); 557 sensors->obj = NULL; 558 mutex_unlock(&sensors->lock); 559 } 560 561 static void dell_wmi_ddv_hwmon_cache_destroy(void *data) 562 { 563 struct dell_wmi_ddv_sensors *sensors = data; 564 565 sensors->active = false; 566 mutex_destroy(&sensors->lock); 567 kfree(sensors->obj); 568 } 569 570 static struct hwmon_channel_info *dell_wmi_ddv_channel_init(struct wmi_device *wdev, 571 enum dell_ddv_method method, 572 struct dell_wmi_ddv_sensors *sensors, 573 size_t entry_size, 574 enum hwmon_sensor_types type, 575 u32 config) 576 { 577 struct hwmon_channel_info *info; 578 int ret; 579 580 ret = dell_wmi_ddv_update_sensors(wdev, method, sensors, entry_size); 581 if (ret < 0) 582 return ERR_PTR(ret); 583 584 mutex_init(&sensors->lock); 585 sensors->active = true; 586 587 ret = devm_add_action_or_reset(&wdev->dev, dell_wmi_ddv_hwmon_cache_destroy, sensors); 588 if (ret < 0) 589 return ERR_PTR(ret); 590 591 info = dell_wmi_ddv_channel_create(&wdev->dev, sensors->entries, type, config); 592 if (IS_ERR(info)) 593 devm_release_action(&wdev->dev, dell_wmi_ddv_hwmon_cache_destroy, sensors); 594 595 return info; 596 } 597 598 static int dell_wmi_ddv_hwmon_add(struct dell_wmi_ddv_data *data) 599 { 600 struct wmi_device *wdev = data->wdev; 601 struct combined_chip_info *cinfo; 602 struct hwmon_channel_info *info; 603 struct device *hdev; 604 int index = 0; 605 int ret; 606 607 if (!devres_open_group(&wdev->dev, dell_wmi_ddv_hwmon_add, GFP_KERNEL)) 608 return -ENOMEM; 609 610 cinfo = devm_kzalloc(&wdev->dev, struct_size(cinfo, info, 4), GFP_KERNEL); 611 if (!cinfo) { 612 ret = -ENOMEM; 613 614 goto err_release; 615 } 616 617 cinfo->chip.ops = &dell_wmi_ddv_ops; 618 cinfo->chip.info = cinfo->info; 619 620 info = dell_wmi_ddv_channel_create(&wdev->dev, 1, hwmon_chip, HWMON_C_REGISTER_TZ); 621 if (IS_ERR(info)) { 622 ret = PTR_ERR(info); 623 624 goto err_release; 625 } 626 627 cinfo->info[index] = info; 628 index++; 629 630 info = dell_wmi_ddv_channel_init(wdev, DELL_DDV_FAN_SENSOR_INFORMATION, &data->fans, 631 sizeof(struct fan_sensor_entry), hwmon_fan, 632 (HWMON_F_INPUT | HWMON_F_LABEL)); 633 if (!IS_ERR(info)) { 634 cinfo->info[index] = info; 635 index++; 636 } 637 638 info = dell_wmi_ddv_channel_init(wdev, DELL_DDV_THERMAL_SENSOR_INFORMATION, &data->temps, 639 sizeof(struct thermal_sensor_entry), hwmon_temp, 640 (HWMON_T_INPUT | HWMON_T_MIN | HWMON_T_MAX | 641 HWMON_T_LABEL)); 642 if (!IS_ERR(info)) { 643 cinfo->info[index] = info; 644 index++; 645 } 646 647 if (index < 2) { 648 /* Finding no available sensors is not an error */ 649 ret = 0; 650 651 goto err_release; 652 } 653 654 hdev = devm_hwmon_device_register_with_info(&wdev->dev, "dell_ddv", data, &cinfo->chip, 655 NULL); 656 if (IS_ERR(hdev)) { 657 ret = PTR_ERR(hdev); 658 659 goto err_release; 660 } 661 662 devres_close_group(&wdev->dev, dell_wmi_ddv_hwmon_add); 663 664 return 0; 665 666 err_release: 667 devres_release_group(&wdev->dev, dell_wmi_ddv_hwmon_add); 668 669 return ret; 670 } 671 672 static int dell_wmi_ddv_battery_translate(struct dell_wmi_ddv_data *data, 673 struct power_supply *battery, u32 *index) 674 { 675 u32 serial_dec, serial_hex, serial; 676 union power_supply_propval val; 677 int ret; 678 679 guard(mutex)(&data->translation_cache_lock); 680 681 for (int i = 0; i < ARRAY_SIZE(data->translation_cache); i++) { 682 if (data->translation_cache[i] == battery) { 683 dev_dbg(&data->wdev->dev, "Translation cache hit for battery index %u\n", 684 i + 1); 685 *index = i + 1; 686 return 0; 687 } 688 } 689 690 dev_dbg(&data->wdev->dev, "Translation cache miss\n"); 691 692 /* Perform a translation between a ACPI battery and a battery index */ 693 694 ret = power_supply_get_property(battery, POWER_SUPPLY_PROP_SERIAL_NUMBER, &val); 695 if (ret < 0) 696 return ret; 697 698 /* 699 * Some devices display the serial number of the ACPI battery (string!) as a decimal 700 * number while other devices display it as a hexadecimal number. Because of this we 701 * have to check both cases. 702 */ 703 ret = kstrtou32(val.strval, 16, &serial_hex); 704 if (ret < 0) 705 return ret; /* Should never fail */ 706 707 ret = kstrtou32(val.strval, 10, &serial_dec); 708 if (ret < 0) 709 serial_dec = 0; /* Can fail, thus we only mark serial_dec as invalid */ 710 711 for (int i = 0; i < ARRAY_SIZE(data->translation_cache); i++) { 712 ret = dell_wmi_ddv_query_integer(data->wdev, DELL_DDV_BATTERY_SERIAL_NUMBER, i + 1, 713 &serial); 714 if (ret < 0) 715 return ret; 716 717 /* A serial number of 0 signals that this index is not associated with a battery */ 718 if (!serial) 719 continue; 720 721 if (serial == serial_dec || serial == serial_hex) { 722 dev_dbg(&data->wdev->dev, "Translation cache update for battery index %u\n", 723 i + 1); 724 data->translation_cache[i] = battery; 725 *index = i + 1; 726 return 0; 727 } 728 } 729 730 return -ENODEV; 731 } 732 733 static void dell_wmi_battery_invalidate(struct dell_wmi_ddv_data *data, 734 struct power_supply *battery) 735 { 736 guard(mutex)(&data->translation_cache_lock); 737 738 for (int i = 0; i < ARRAY_SIZE(data->translation_cache); i++) { 739 if (data->translation_cache[i] == battery) { 740 data->translation_cache[i] = NULL; 741 return; 742 } 743 } 744 } 745 746 static ssize_t eppid_show(struct device *dev, struct device_attribute *attr, char *buf) 747 { 748 struct dell_wmi_ddv_data *data = container_of(attr, struct dell_wmi_ddv_data, eppid_attr); 749 union acpi_object *obj; 750 u32 index; 751 int ret; 752 753 ret = dell_wmi_ddv_battery_translate(data, to_power_supply(dev), &index); 754 if (ret < 0) 755 return ret; 756 757 ret = dell_wmi_ddv_query_string(data->wdev, DELL_DDV_BATTERY_EPPID, index, &obj); 758 if (ret < 0) 759 return ret; 760 761 if (obj->string.length != DELL_EPPID_LENGTH && obj->string.length != DELL_EPPID_EXT_LENGTH) 762 dev_info_once(&data->wdev->dev, FW_INFO "Suspicious ePPID length (%d)\n", 763 obj->string.length); 764 765 ret = sysfs_emit(buf, "%s\n", obj->string.pointer); 766 767 kfree(obj); 768 769 return ret; 770 } 771 772 static int dell_wmi_ddv_get_health(struct dell_wmi_ddv_data *data, u32 index, 773 union power_supply_propval *val) 774 { 775 u32 value, code; 776 int ret; 777 778 ret = dell_wmi_ddv_query_integer(data->wdev, DELL_DDV_BATTERY_MANUFACTURER_ACCESS, index, 779 &value); 780 if (ret < 0) 781 return ret; 782 783 switch (FIELD_GET(MA_FAILURE_MODE_MASK, value)) { 784 case MA_FAILURE_MODE_PERMANENT: 785 code = FIELD_GET(MA_PERMANENT_FAILURE_CODE_MASK, value); 786 switch (code) { 787 case MA_PERMANENT_FAILURE_FUSE_BLOWN: 788 val->intval = POWER_SUPPLY_HEALTH_BLOWN_FUSE; 789 return 0; 790 case MA_PERMANENT_FAILURE_CELL_IMBALANCE: 791 val->intval = POWER_SUPPLY_HEALTH_CELL_IMBALANCE; 792 return 0; 793 case MA_PERMANENT_FAILURE_OVERVOLTAGE: 794 val->intval = POWER_SUPPLY_HEALTH_OVERVOLTAGE; 795 return 0; 796 case MA_PERMANENT_FAILURE_FET_FAILURE: 797 val->intval = POWER_SUPPLY_HEALTH_DEAD; 798 return 0; 799 default: 800 dev_notice_once(&data->wdev->dev, "Unknown permanent failure code %u\n", 801 code); 802 val->intval = POWER_SUPPLY_HEALTH_UNSPEC_FAILURE; 803 return 0; 804 } 805 case MA_FAILURE_MODE_OVERHEAT: 806 code = FIELD_GET(MA_OVERHEAT_FAILURE_CODE_MASK, value); 807 switch (code) { 808 case MA_OVERHEAT_FAILURE_START: 809 case MA_OVERHEAT_FAILURE_CHARGING: 810 case MA_OVERHEAT_FAILURE_DISCHARGING: 811 val->intval = POWER_SUPPLY_HEALTH_OVERHEAT; 812 return 0; 813 default: 814 dev_notice_once(&data->wdev->dev, "Unknown overheat failure code %u\n", 815 code); 816 val->intval = POWER_SUPPLY_HEALTH_UNSPEC_FAILURE; 817 return 0; 818 } 819 case MA_FAILURE_MODE_OVERCURRENT: 820 code = FIELD_GET(MA_OVERCURRENT_FAILURE_CODE_MASK, value); 821 switch (code) { 822 case MA_OVERCURRENT_FAILURE_CHARGING: 823 case MA_OVERCURRENT_FAILURE_DISCHARGING: 824 val->intval = POWER_SUPPLY_HEALTH_OVERCURRENT; 825 return 0; 826 default: 827 dev_notice_once(&data->wdev->dev, "Unknown overcurrent failure code %u\n", 828 code); 829 val->intval = POWER_SUPPLY_HEALTH_UNSPEC_FAILURE; 830 return 0; 831 } 832 default: 833 val->intval = POWER_SUPPLY_HEALTH_GOOD; 834 return 0; 835 } 836 } 837 838 static int dell_wmi_ddv_get_manufacture_date(struct dell_wmi_ddv_data *data, u32 index, 839 enum power_supply_property psp, 840 union power_supply_propval *val) 841 { 842 u16 year, month, day; 843 u32 value; 844 int ret; 845 846 ret = dell_wmi_ddv_query_integer(data->wdev, DELL_DDV_BATTERY_MANUFACTURE_DATE, 847 index, &value); 848 if (ret < 0) 849 return ret; 850 if (value > U16_MAX) 851 return -ENXIO; 852 853 /* 854 * Some devices report a invalid manufacture date value 855 * like 0.0.1980. Because of this we have to check the 856 * whole value before exposing parts of it to user space. 857 */ 858 year = FIELD_GET(SBS_MANUFACTURE_YEAR_MASK, value) + 1980; 859 month = FIELD_GET(SBS_MANUFACTURE_MONTH_MASK, value); 860 if (month < 1 || month > 12) 861 return -ENODATA; 862 863 day = FIELD_GET(SBS_MANUFACTURE_DAY_MASK, value); 864 if (day < 1 || day > 31) 865 return -ENODATA; 866 867 switch (psp) { 868 case POWER_SUPPLY_PROP_MANUFACTURE_YEAR: 869 val->intval = year; 870 return 0; 871 case POWER_SUPPLY_PROP_MANUFACTURE_MONTH: 872 val->intval = month; 873 return 0; 874 case POWER_SUPPLY_PROP_MANUFACTURE_DAY: 875 val->intval = day; 876 return 0; 877 default: 878 return -EINVAL; 879 } 880 } 881 882 static int dell_wmi_ddv_get_property(struct power_supply *psy, const struct power_supply_ext *ext, 883 void *drvdata, enum power_supply_property psp, 884 union power_supply_propval *val) 885 { 886 struct dell_wmi_ddv_data *data = drvdata; 887 u32 index, value; 888 int ret; 889 890 ret = dell_wmi_ddv_battery_translate(data, psy, &index); 891 if (ret < 0) 892 return ret; 893 894 switch (psp) { 895 case POWER_SUPPLY_PROP_HEALTH: 896 return dell_wmi_ddv_get_health(data, index, val); 897 case POWER_SUPPLY_PROP_TEMP: 898 ret = dell_wmi_ddv_query_integer(data->wdev, DELL_DDV_BATTERY_TEMPERATURE, index, 899 &value); 900 if (ret < 0) 901 return ret; 902 903 /* Use 2732 instead of 2731.5 to avoid unnecessary rounding and to emulate 904 * the behaviour of the OEM application which seems to round down the result. 905 */ 906 val->intval = value - 2732; 907 return 0; 908 case POWER_SUPPLY_PROP_MANUFACTURE_YEAR: 909 case POWER_SUPPLY_PROP_MANUFACTURE_MONTH: 910 case POWER_SUPPLY_PROP_MANUFACTURE_DAY: 911 return dell_wmi_ddv_get_manufacture_date(data, index, psp, val); 912 default: 913 return -EINVAL; 914 } 915 } 916 917 static const enum power_supply_property dell_wmi_ddv_properties[] = { 918 POWER_SUPPLY_PROP_HEALTH, 919 POWER_SUPPLY_PROP_TEMP, 920 POWER_SUPPLY_PROP_MANUFACTURE_YEAR, 921 POWER_SUPPLY_PROP_MANUFACTURE_MONTH, 922 POWER_SUPPLY_PROP_MANUFACTURE_DAY, 923 }; 924 925 static const struct power_supply_ext dell_wmi_ddv_extension = { 926 .name = DRIVER_NAME, 927 .properties = dell_wmi_ddv_properties, 928 .num_properties = ARRAY_SIZE(dell_wmi_ddv_properties), 929 .get_property = dell_wmi_ddv_get_property, 930 }; 931 932 static int dell_wmi_ddv_add_battery(struct power_supply *battery, struct acpi_battery_hook *hook) 933 { 934 struct dell_wmi_ddv_data *data = container_of(hook, struct dell_wmi_ddv_data, hook); 935 int ret; 936 937 /* 938 * We cannot do the battery matching here since the battery might be absent, preventing 939 * us from reading the serial number. 940 */ 941 942 ret = device_create_file(&battery->dev, &data->eppid_attr); 943 if (ret < 0) 944 return ret; 945 946 ret = power_supply_register_extension(battery, &dell_wmi_ddv_extension, &data->wdev->dev, 947 data); 948 if (ret < 0) { 949 device_remove_file(&battery->dev, &data->eppid_attr); 950 951 return ret; 952 } 953 954 return 0; 955 } 956 957 static int dell_wmi_ddv_remove_battery(struct power_supply *battery, struct acpi_battery_hook *hook) 958 { 959 struct dell_wmi_ddv_data *data = container_of(hook, struct dell_wmi_ddv_data, hook); 960 961 device_remove_file(&battery->dev, &data->eppid_attr); 962 power_supply_unregister_extension(battery, &dell_wmi_ddv_extension); 963 964 dell_wmi_battery_invalidate(data, battery); 965 966 return 0; 967 } 968 969 static int dell_wmi_ddv_battery_add(struct dell_wmi_ddv_data *data) 970 { 971 int ret; 972 973 ret = devm_mutex_init(&data->wdev->dev, &data->translation_cache_lock); 974 if (ret < 0) 975 return ret; 976 977 data->hook.name = "Dell DDV Battery Extension"; 978 data->hook.add_battery = dell_wmi_ddv_add_battery; 979 data->hook.remove_battery = dell_wmi_ddv_remove_battery; 980 981 sysfs_attr_init(&data->eppid_attr.attr); 982 data->eppid_attr.attr.name = "eppid"; 983 data->eppid_attr.attr.mode = 0444; 984 data->eppid_attr.show = eppid_show; 985 986 return devm_battery_hook_register(&data->wdev->dev, &data->hook); 987 } 988 989 static int dell_wmi_ddv_buffer_read(struct seq_file *seq, enum dell_ddv_method method) 990 { 991 struct device *dev = seq->private; 992 struct dell_wmi_ddv_data *data = dev_get_drvdata(dev); 993 union acpi_object *obj; 994 u64 size; 995 u8 *buf; 996 int ret; 997 998 ret = dell_wmi_ddv_query_buffer(data->wdev, method, 0, &obj); 999 if (ret < 0) 1000 return ret; 1001 1002 size = obj->package.elements[0].integer.value; 1003 buf = obj->package.elements[1].buffer.pointer; 1004 ret = seq_write(seq, buf, size); 1005 kfree(obj); 1006 1007 return ret; 1008 } 1009 1010 static int dell_wmi_ddv_fan_read(struct seq_file *seq, void *offset) 1011 { 1012 return dell_wmi_ddv_buffer_read(seq, DELL_DDV_FAN_SENSOR_INFORMATION); 1013 } 1014 1015 static int dell_wmi_ddv_temp_read(struct seq_file *seq, void *offset) 1016 { 1017 return dell_wmi_ddv_buffer_read(seq, DELL_DDV_THERMAL_SENSOR_INFORMATION); 1018 } 1019 1020 static void dell_wmi_ddv_debugfs_remove(void *data) 1021 { 1022 struct dentry *entry = data; 1023 1024 debugfs_remove(entry); 1025 } 1026 1027 static void dell_wmi_ddv_debugfs_init(struct wmi_device *wdev) 1028 { 1029 struct dentry *entry; 1030 char name[64]; 1031 1032 scnprintf(name, ARRAY_SIZE(name), "%s-%s", DRIVER_NAME, dev_name(&wdev->dev)); 1033 entry = debugfs_create_dir(name, NULL); 1034 1035 debugfs_create_devm_seqfile(&wdev->dev, "fan_sensor_information", entry, 1036 dell_wmi_ddv_fan_read); 1037 debugfs_create_devm_seqfile(&wdev->dev, "thermal_sensor_information", entry, 1038 dell_wmi_ddv_temp_read); 1039 1040 devm_add_action_or_reset(&wdev->dev, dell_wmi_ddv_debugfs_remove, entry); 1041 } 1042 1043 static int dell_wmi_ddv_probe(struct wmi_device *wdev, const void *context) 1044 { 1045 struct dell_wmi_ddv_data *data; 1046 u32 version; 1047 int ret; 1048 1049 ret = dell_wmi_ddv_query_integer(wdev, DELL_DDV_INTERFACE_VERSION, 0, &version); 1050 if (ret < 0) 1051 return ret; 1052 1053 dev_dbg(&wdev->dev, "WMI interface version: %d\n", version); 1054 if (version < DELL_DDV_SUPPORTED_VERSION_MIN || version > DELL_DDV_SUPPORTED_VERSION_MAX) { 1055 if (!force) 1056 return -ENODEV; 1057 1058 dev_warn(&wdev->dev, "Loading despite unsupported WMI interface version (%u)\n", 1059 version); 1060 } 1061 1062 data = devm_kzalloc(&wdev->dev, sizeof(*data), GFP_KERNEL); 1063 if (!data) 1064 return -ENOMEM; 1065 1066 dev_set_drvdata(&wdev->dev, data); 1067 data->wdev = wdev; 1068 1069 dell_wmi_ddv_debugfs_init(wdev); 1070 1071 if (IS_REACHABLE(CONFIG_ACPI_BATTERY)) { 1072 ret = dell_wmi_ddv_battery_add(data); 1073 if (ret < 0) 1074 dev_warn(&wdev->dev, "Unable to register ACPI battery hook: %d\n", ret); 1075 } 1076 1077 if (IS_REACHABLE(CONFIG_HWMON)) { 1078 ret = dell_wmi_ddv_hwmon_add(data); 1079 if (ret < 0) 1080 dev_warn(&wdev->dev, "Unable to register hwmon interface: %d\n", ret); 1081 } 1082 1083 return 0; 1084 } 1085 1086 static int dell_wmi_ddv_resume(struct device *dev) 1087 { 1088 struct dell_wmi_ddv_data *data = dev_get_drvdata(dev); 1089 1090 /* Force re-reading of all active sensors */ 1091 dell_wmi_ddv_hwmon_cache_invalidate(&data->fans); 1092 dell_wmi_ddv_hwmon_cache_invalidate(&data->temps); 1093 1094 return 0; 1095 } 1096 1097 static DEFINE_SIMPLE_DEV_PM_OPS(dell_wmi_ddv_dev_pm_ops, NULL, dell_wmi_ddv_resume); 1098 1099 static const struct wmi_device_id dell_wmi_ddv_id_table[] = { 1100 { DELL_DDV_GUID, NULL }, 1101 { } 1102 }; 1103 MODULE_DEVICE_TABLE(wmi, dell_wmi_ddv_id_table); 1104 1105 static struct wmi_driver dell_wmi_ddv_driver = { 1106 .driver = { 1107 .name = DRIVER_NAME, 1108 .probe_type = PROBE_PREFER_ASYNCHRONOUS, 1109 .pm = pm_sleep_ptr(&dell_wmi_ddv_dev_pm_ops), 1110 }, 1111 .id_table = dell_wmi_ddv_id_table, 1112 .probe = dell_wmi_ddv_probe, 1113 .no_singleton = true, 1114 }; 1115 module_wmi_driver(dell_wmi_ddv_driver); 1116 1117 MODULE_AUTHOR("Armin Wolf <W_Armin@gmx.de>"); 1118 MODULE_DESCRIPTION("Dell WMI sensor driver"); 1119 MODULE_LICENSE("GPL"); 1120