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