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/debugfs.h> 12 #include <linux/device.h> 13 #include <linux/device/driver.h> 14 #include <linux/dev_printk.h> 15 #include <linux/errno.h> 16 #include <linux/kconfig.h> 17 #include <linux/kernel.h> 18 #include <linux/hwmon.h> 19 #include <linux/kstrtox.h> 20 #include <linux/math64.h> 21 #include <linux/module.h> 22 #include <linux/mutex.h> 23 #include <linux/limits.h> 24 #include <linux/pm.h> 25 #include <linux/power_supply.h> 26 #include <linux/printk.h> 27 #include <linux/seq_file.h> 28 #include <linux/sysfs.h> 29 #include <linux/types.h> 30 #include <linux/wmi.h> 31 32 #include <acpi/battery.h> 33 34 #include <linux/unaligned.h> 35 36 #define DRIVER_NAME "dell-wmi-ddv" 37 38 #define DELL_DDV_SUPPORTED_VERSION_MIN 2 39 #define DELL_DDV_SUPPORTED_VERSION_MAX 3 40 #define DELL_DDV_GUID "8A42EA14-4F2A-FD45-6422-0087F7A7E608" 41 42 #define DELL_EPPID_LENGTH 20 43 #define DELL_EPPID_EXT_LENGTH 23 44 45 static bool force; 46 module_param_unsafe(force, bool, 0); 47 MODULE_PARM_DESC(force, "Force loading without checking for supported WMI interface versions"); 48 49 enum dell_ddv_method { 50 DELL_DDV_BATTERY_DESIGN_CAPACITY = 0x01, 51 DELL_DDV_BATTERY_FULL_CHARGE_CAPACITY = 0x02, 52 DELL_DDV_BATTERY_MANUFACTURE_NAME = 0x03, 53 DELL_DDV_BATTERY_MANUFACTURE_DATE = 0x04, 54 DELL_DDV_BATTERY_SERIAL_NUMBER = 0x05, 55 DELL_DDV_BATTERY_CHEMISTRY_VALUE = 0x06, 56 DELL_DDV_BATTERY_TEMPERATURE = 0x07, 57 DELL_DDV_BATTERY_CURRENT = 0x08, 58 DELL_DDV_BATTERY_VOLTAGE = 0x09, 59 DELL_DDV_BATTERY_MANUFACTURER_ACCESS = 0x0A, 60 DELL_DDV_BATTERY_RELATIVE_CHARGE_STATE = 0x0B, 61 DELL_DDV_BATTERY_CYCLE_COUNT = 0x0C, 62 DELL_DDV_BATTERY_EPPID = 0x0D, 63 DELL_DDV_BATTERY_RAW_ANALYTICS_START = 0x0E, 64 DELL_DDV_BATTERY_RAW_ANALYTICS = 0x0F, 65 DELL_DDV_BATTERY_DESIGN_VOLTAGE = 0x10, 66 DELL_DDV_BATTERY_RAW_ANALYTICS_A_BLOCK = 0x11, /* version 3 */ 67 68 DELL_DDV_INTERFACE_VERSION = 0x12, 69 70 DELL_DDV_FAN_SENSOR_INFORMATION = 0x20, 71 DELL_DDV_THERMAL_SENSOR_INFORMATION = 0x22, 72 }; 73 74 struct fan_sensor_entry { 75 u8 type; 76 __le16 rpm; 77 } __packed; 78 79 struct thermal_sensor_entry { 80 u8 type; 81 s8 now; 82 s8 min; 83 s8 max; 84 u8 unknown; 85 } __packed; 86 87 struct combined_channel_info { 88 struct hwmon_channel_info info; 89 u32 config[]; 90 }; 91 92 struct combined_chip_info { 93 struct hwmon_chip_info chip; 94 const struct hwmon_channel_info *info[]; 95 }; 96 97 struct dell_wmi_ddv_sensors { 98 bool active; 99 struct mutex lock; /* protect caching */ 100 unsigned long timestamp; 101 union acpi_object *obj; 102 u64 entries; 103 }; 104 105 struct dell_wmi_ddv_data { 106 struct acpi_battery_hook hook; 107 struct device_attribute eppid_attr; 108 struct dell_wmi_ddv_sensors fans; 109 struct dell_wmi_ddv_sensors temps; 110 struct wmi_device *wdev; 111 }; 112 113 static const char * const fan_labels[] = { 114 "CPU Fan", 115 "Chassis Motherboard Fan", 116 "Video Fan", 117 "Power Supply Fan", 118 "Chipset Fan", 119 "Memory Fan", 120 "PCI Fan", 121 "HDD Fan", 122 }; 123 124 static const char * const fan_dock_labels[] = { 125 "Docking Chassis/Motherboard Fan", 126 "Docking Video Fan", 127 "Docking Power Supply Fan", 128 "Docking Chipset Fan", 129 }; 130 131 static int dell_wmi_ddv_query_type(struct wmi_device *wdev, enum dell_ddv_method method, u32 arg, 132 union acpi_object **result, acpi_object_type type) 133 { 134 struct acpi_buffer out = { ACPI_ALLOCATE_BUFFER, NULL }; 135 const struct acpi_buffer in = { 136 .length = sizeof(arg), 137 .pointer = &arg, 138 }; 139 union acpi_object *obj; 140 acpi_status ret; 141 142 ret = wmidev_evaluate_method(wdev, 0x0, method, &in, &out); 143 if (ACPI_FAILURE(ret)) 144 return -EIO; 145 146 obj = out.pointer; 147 if (!obj) 148 return -ENODATA; 149 150 if (obj->type != type) { 151 kfree(obj); 152 return -ENOMSG; 153 } 154 155 *result = obj; 156 157 return 0; 158 } 159 160 static int dell_wmi_ddv_query_integer(struct wmi_device *wdev, enum dell_ddv_method method, 161 u32 arg, u32 *res) 162 { 163 union acpi_object *obj; 164 int ret; 165 166 ret = dell_wmi_ddv_query_type(wdev, method, arg, &obj, ACPI_TYPE_INTEGER); 167 if (ret < 0) 168 return ret; 169 170 if (obj->integer.value <= U32_MAX) 171 *res = (u32)obj->integer.value; 172 else 173 ret = -ERANGE; 174 175 kfree(obj); 176 177 return ret; 178 } 179 180 static int dell_wmi_ddv_query_buffer(struct wmi_device *wdev, enum dell_ddv_method method, 181 u32 arg, union acpi_object **result) 182 { 183 union acpi_object *obj; 184 u64 buffer_size; 185 int ret; 186 187 ret = dell_wmi_ddv_query_type(wdev, method, arg, &obj, ACPI_TYPE_PACKAGE); 188 if (ret < 0) 189 return ret; 190 191 if (obj->package.count != 2 || 192 obj->package.elements[0].type != ACPI_TYPE_INTEGER || 193 obj->package.elements[1].type != ACPI_TYPE_BUFFER) { 194 ret = -ENOMSG; 195 196 goto err_free; 197 } 198 199 buffer_size = obj->package.elements[0].integer.value; 200 201 if (!buffer_size) { 202 ret = -ENODATA; 203 204 goto err_free; 205 } 206 207 if (buffer_size > obj->package.elements[1].buffer.length) { 208 dev_warn(&wdev->dev, 209 FW_WARN "WMI buffer size (%llu) exceeds ACPI buffer size (%d)\n", 210 buffer_size, obj->package.elements[1].buffer.length); 211 ret = -EMSGSIZE; 212 213 goto err_free; 214 } 215 216 *result = obj; 217 218 return 0; 219 220 err_free: 221 kfree(obj); 222 223 return ret; 224 } 225 226 static int dell_wmi_ddv_query_string(struct wmi_device *wdev, enum dell_ddv_method method, 227 u32 arg, union acpi_object **result) 228 { 229 return dell_wmi_ddv_query_type(wdev, method, arg, result, ACPI_TYPE_STRING); 230 } 231 232 /* 233 * Needs to be called with lock held, except during initialization. 234 */ 235 static int dell_wmi_ddv_update_sensors(struct wmi_device *wdev, enum dell_ddv_method method, 236 struct dell_wmi_ddv_sensors *sensors, size_t entry_size) 237 { 238 u64 buffer_size, rem, entries; 239 union acpi_object *obj; 240 u8 *buffer; 241 int ret; 242 243 if (sensors->obj) { 244 if (time_before(jiffies, sensors->timestamp + HZ)) 245 return 0; 246 247 kfree(sensors->obj); 248 sensors->obj = NULL; 249 } 250 251 ret = dell_wmi_ddv_query_buffer(wdev, method, 0, &obj); 252 if (ret < 0) 253 return ret; 254 255 /* buffer format sanity check */ 256 buffer_size = obj->package.elements[0].integer.value; 257 buffer = obj->package.elements[1].buffer.pointer; 258 entries = div64_u64_rem(buffer_size, entry_size, &rem); 259 if (rem != 1 || buffer[buffer_size - 1] != 0xff) { 260 ret = -ENOMSG; 261 goto err_free; 262 } 263 264 if (!entries) { 265 ret = -ENODATA; 266 goto err_free; 267 } 268 269 sensors->obj = obj; 270 sensors->entries = entries; 271 sensors->timestamp = jiffies; 272 273 return 0; 274 275 err_free: 276 kfree(obj); 277 278 return ret; 279 } 280 281 static umode_t dell_wmi_ddv_is_visible(const void *drvdata, enum hwmon_sensor_types type, u32 attr, 282 int channel) 283 { 284 return 0444; 285 } 286 287 static int dell_wmi_ddv_fan_read_channel(struct dell_wmi_ddv_data *data, u32 attr, int channel, 288 long *val) 289 { 290 struct fan_sensor_entry *entry; 291 int ret; 292 293 ret = dell_wmi_ddv_update_sensors(data->wdev, DELL_DDV_FAN_SENSOR_INFORMATION, 294 &data->fans, sizeof(*entry)); 295 if (ret < 0) 296 return ret; 297 298 if (channel >= data->fans.entries) 299 return -ENXIO; 300 301 entry = (struct fan_sensor_entry *)data->fans.obj->package.elements[1].buffer.pointer; 302 switch (attr) { 303 case hwmon_fan_input: 304 *val = get_unaligned_le16(&entry[channel].rpm); 305 return 0; 306 default: 307 break; 308 } 309 310 return -EOPNOTSUPP; 311 } 312 313 static int dell_wmi_ddv_temp_read_channel(struct dell_wmi_ddv_data *data, u32 attr, int channel, 314 long *val) 315 { 316 struct thermal_sensor_entry *entry; 317 int ret; 318 319 ret = dell_wmi_ddv_update_sensors(data->wdev, DELL_DDV_THERMAL_SENSOR_INFORMATION, 320 &data->temps, sizeof(*entry)); 321 if (ret < 0) 322 return ret; 323 324 if (channel >= data->temps.entries) 325 return -ENXIO; 326 327 entry = (struct thermal_sensor_entry *)data->temps.obj->package.elements[1].buffer.pointer; 328 switch (attr) { 329 case hwmon_temp_input: 330 *val = entry[channel].now * 1000; 331 return 0; 332 case hwmon_temp_min: 333 *val = entry[channel].min * 1000; 334 return 0; 335 case hwmon_temp_max: 336 *val = entry[channel].max * 1000; 337 return 0; 338 default: 339 break; 340 } 341 342 return -EOPNOTSUPP; 343 } 344 345 static int dell_wmi_ddv_read(struct device *dev, enum hwmon_sensor_types type, u32 attr, 346 int channel, long *val) 347 { 348 struct dell_wmi_ddv_data *data = dev_get_drvdata(dev); 349 int ret; 350 351 switch (type) { 352 case hwmon_fan: 353 mutex_lock(&data->fans.lock); 354 ret = dell_wmi_ddv_fan_read_channel(data, attr, channel, val); 355 mutex_unlock(&data->fans.lock); 356 return ret; 357 case hwmon_temp: 358 mutex_lock(&data->temps.lock); 359 ret = dell_wmi_ddv_temp_read_channel(data, attr, channel, val); 360 mutex_unlock(&data->temps.lock); 361 return ret; 362 default: 363 break; 364 } 365 366 return -EOPNOTSUPP; 367 } 368 369 static int dell_wmi_ddv_fan_read_string(struct dell_wmi_ddv_data *data, int channel, 370 const char **str) 371 { 372 struct fan_sensor_entry *entry; 373 int ret; 374 u8 type; 375 376 ret = dell_wmi_ddv_update_sensors(data->wdev, DELL_DDV_FAN_SENSOR_INFORMATION, 377 &data->fans, sizeof(*entry)); 378 if (ret < 0) 379 return ret; 380 381 if (channel >= data->fans.entries) 382 return -ENXIO; 383 384 entry = (struct fan_sensor_entry *)data->fans.obj->package.elements[1].buffer.pointer; 385 type = entry[channel].type; 386 switch (type) { 387 case 0x00 ... 0x07: 388 *str = fan_labels[type]; 389 break; 390 case 0x11 ... 0x14: 391 *str = fan_dock_labels[type - 0x11]; 392 break; 393 default: 394 *str = "Unknown Fan"; 395 break; 396 } 397 398 return 0; 399 } 400 401 static int dell_wmi_ddv_temp_read_string(struct dell_wmi_ddv_data *data, int channel, 402 const char **str) 403 { 404 struct thermal_sensor_entry *entry; 405 int ret; 406 407 ret = dell_wmi_ddv_update_sensors(data->wdev, DELL_DDV_THERMAL_SENSOR_INFORMATION, 408 &data->temps, sizeof(*entry)); 409 if (ret < 0) 410 return ret; 411 412 if (channel >= data->temps.entries) 413 return -ENXIO; 414 415 entry = (struct thermal_sensor_entry *)data->temps.obj->package.elements[1].buffer.pointer; 416 switch (entry[channel].type) { 417 case 0x00: 418 *str = "CPU"; 419 break; 420 case 0x11: 421 *str = "Video"; 422 break; 423 case 0x22: 424 *str = "Memory"; /* sometimes called DIMM */ 425 break; 426 case 0x33: 427 *str = "Other"; 428 break; 429 case 0x44: 430 *str = "Ambient"; /* sometimes called SKIN */ 431 break; 432 case 0x52: 433 *str = "SODIMM"; 434 break; 435 case 0x55: 436 *str = "HDD"; 437 break; 438 case 0x62: 439 *str = "SODIMM 2"; 440 break; 441 case 0x73: 442 *str = "NB"; 443 break; 444 case 0x83: 445 *str = "Charger"; 446 break; 447 case 0xbb: 448 *str = "Memory 3"; 449 break; 450 default: 451 *str = "Unknown"; 452 break; 453 } 454 455 return 0; 456 } 457 458 static int dell_wmi_ddv_read_string(struct device *dev, enum hwmon_sensor_types type, u32 attr, 459 int channel, const char **str) 460 { 461 struct dell_wmi_ddv_data *data = dev_get_drvdata(dev); 462 int ret; 463 464 switch (type) { 465 case hwmon_fan: 466 switch (attr) { 467 case hwmon_fan_label: 468 mutex_lock(&data->fans.lock); 469 ret = dell_wmi_ddv_fan_read_string(data, channel, str); 470 mutex_unlock(&data->fans.lock); 471 return ret; 472 default: 473 break; 474 } 475 break; 476 case hwmon_temp: 477 switch (attr) { 478 case hwmon_temp_label: 479 mutex_lock(&data->temps.lock); 480 ret = dell_wmi_ddv_temp_read_string(data, channel, str); 481 mutex_unlock(&data->temps.lock); 482 return ret; 483 default: 484 break; 485 } 486 break; 487 default: 488 break; 489 } 490 491 return -EOPNOTSUPP; 492 } 493 494 static const struct hwmon_ops dell_wmi_ddv_ops = { 495 .is_visible = dell_wmi_ddv_is_visible, 496 .read = dell_wmi_ddv_read, 497 .read_string = dell_wmi_ddv_read_string, 498 }; 499 500 static struct hwmon_channel_info *dell_wmi_ddv_channel_create(struct device *dev, u64 count, 501 enum hwmon_sensor_types type, 502 u32 config) 503 { 504 struct combined_channel_info *cinfo; 505 int i; 506 507 cinfo = devm_kzalloc(dev, struct_size(cinfo, config, count + 1), GFP_KERNEL); 508 if (!cinfo) 509 return ERR_PTR(-ENOMEM); 510 511 cinfo->info.type = type; 512 cinfo->info.config = cinfo->config; 513 514 for (i = 0; i < count; i++) 515 cinfo->config[i] = config; 516 517 return &cinfo->info; 518 } 519 520 static void dell_wmi_ddv_hwmon_cache_invalidate(struct dell_wmi_ddv_sensors *sensors) 521 { 522 if (!sensors->active) 523 return; 524 525 mutex_lock(&sensors->lock); 526 kfree(sensors->obj); 527 sensors->obj = NULL; 528 mutex_unlock(&sensors->lock); 529 } 530 531 static void dell_wmi_ddv_hwmon_cache_destroy(void *data) 532 { 533 struct dell_wmi_ddv_sensors *sensors = data; 534 535 sensors->active = false; 536 mutex_destroy(&sensors->lock); 537 kfree(sensors->obj); 538 } 539 540 static struct hwmon_channel_info *dell_wmi_ddv_channel_init(struct wmi_device *wdev, 541 enum dell_ddv_method method, 542 struct dell_wmi_ddv_sensors *sensors, 543 size_t entry_size, 544 enum hwmon_sensor_types type, 545 u32 config) 546 { 547 struct hwmon_channel_info *info; 548 int ret; 549 550 ret = dell_wmi_ddv_update_sensors(wdev, method, sensors, entry_size); 551 if (ret < 0) 552 return ERR_PTR(ret); 553 554 mutex_init(&sensors->lock); 555 sensors->active = true; 556 557 ret = devm_add_action_or_reset(&wdev->dev, dell_wmi_ddv_hwmon_cache_destroy, sensors); 558 if (ret < 0) 559 return ERR_PTR(ret); 560 561 info = dell_wmi_ddv_channel_create(&wdev->dev, sensors->entries, type, config); 562 if (IS_ERR(info)) 563 devm_release_action(&wdev->dev, dell_wmi_ddv_hwmon_cache_destroy, sensors); 564 565 return info; 566 } 567 568 static int dell_wmi_ddv_hwmon_add(struct dell_wmi_ddv_data *data) 569 { 570 struct wmi_device *wdev = data->wdev; 571 struct combined_chip_info *cinfo; 572 struct hwmon_channel_info *info; 573 struct device *hdev; 574 int index = 0; 575 int ret; 576 577 if (!devres_open_group(&wdev->dev, dell_wmi_ddv_hwmon_add, GFP_KERNEL)) 578 return -ENOMEM; 579 580 cinfo = devm_kzalloc(&wdev->dev, struct_size(cinfo, info, 4), GFP_KERNEL); 581 if (!cinfo) { 582 ret = -ENOMEM; 583 584 goto err_release; 585 } 586 587 cinfo->chip.ops = &dell_wmi_ddv_ops; 588 cinfo->chip.info = cinfo->info; 589 590 info = dell_wmi_ddv_channel_create(&wdev->dev, 1, hwmon_chip, HWMON_C_REGISTER_TZ); 591 if (IS_ERR(info)) { 592 ret = PTR_ERR(info); 593 594 goto err_release; 595 } 596 597 cinfo->info[index] = info; 598 index++; 599 600 info = dell_wmi_ddv_channel_init(wdev, DELL_DDV_FAN_SENSOR_INFORMATION, &data->fans, 601 sizeof(struct fan_sensor_entry), hwmon_fan, 602 (HWMON_F_INPUT | HWMON_F_LABEL)); 603 if (!IS_ERR(info)) { 604 cinfo->info[index] = info; 605 index++; 606 } 607 608 info = dell_wmi_ddv_channel_init(wdev, DELL_DDV_THERMAL_SENSOR_INFORMATION, &data->temps, 609 sizeof(struct thermal_sensor_entry), hwmon_temp, 610 (HWMON_T_INPUT | HWMON_T_MIN | HWMON_T_MAX | 611 HWMON_T_LABEL)); 612 if (!IS_ERR(info)) { 613 cinfo->info[index] = info; 614 index++; 615 } 616 617 if (index < 2) { 618 /* Finding no available sensors is not an error */ 619 ret = 0; 620 621 goto err_release; 622 } 623 624 hdev = devm_hwmon_device_register_with_info(&wdev->dev, "dell_ddv", data, &cinfo->chip, 625 NULL); 626 if (IS_ERR(hdev)) { 627 ret = PTR_ERR(hdev); 628 629 goto err_release; 630 } 631 632 devres_close_group(&wdev->dev, dell_wmi_ddv_hwmon_add); 633 634 return 0; 635 636 err_release: 637 devres_release_group(&wdev->dev, dell_wmi_ddv_hwmon_add); 638 639 return ret; 640 } 641 642 static int dell_wmi_ddv_battery_index(struct acpi_device *acpi_dev, u32 *index) 643 { 644 const char *uid_str; 645 646 uid_str = acpi_device_uid(acpi_dev); 647 if (!uid_str) 648 return -ENODEV; 649 650 return kstrtou32(uid_str, 10, index); 651 } 652 653 static ssize_t eppid_show(struct device *dev, struct device_attribute *attr, char *buf) 654 { 655 struct dell_wmi_ddv_data *data = container_of(attr, struct dell_wmi_ddv_data, eppid_attr); 656 union acpi_object *obj; 657 u32 index; 658 int ret; 659 660 ret = dell_wmi_ddv_battery_index(to_acpi_device(dev->parent), &index); 661 if (ret < 0) 662 return ret; 663 664 ret = dell_wmi_ddv_query_string(data->wdev, DELL_DDV_BATTERY_EPPID, index, &obj); 665 if (ret < 0) 666 return ret; 667 668 if (obj->string.length != DELL_EPPID_LENGTH && obj->string.length != DELL_EPPID_EXT_LENGTH) 669 dev_info_once(&data->wdev->dev, FW_INFO "Suspicious ePPID length (%d)\n", 670 obj->string.length); 671 672 ret = sysfs_emit(buf, "%s\n", obj->string.pointer); 673 674 kfree(obj); 675 676 return ret; 677 } 678 679 static int dell_wmi_ddv_get_property(struct power_supply *psy, const struct power_supply_ext *ext, 680 void *drvdata, enum power_supply_property psp, 681 union power_supply_propval *val) 682 { 683 struct dell_wmi_ddv_data *data = drvdata; 684 u32 index, value; 685 int ret; 686 687 ret = dell_wmi_ddv_battery_index(to_acpi_device(psy->dev.parent), &index); 688 if (ret < 0) 689 return ret; 690 691 switch (psp) { 692 case POWER_SUPPLY_PROP_TEMP: 693 ret = dell_wmi_ddv_query_integer(data->wdev, DELL_DDV_BATTERY_TEMPERATURE, index, 694 &value); 695 if (ret < 0) 696 return ret; 697 698 /* Use 2732 instead of 2731.5 to avoid unnecessary rounding and to emulate 699 * the behaviour of the OEM application which seems to round down the result. 700 */ 701 val->intval = value - 2732; 702 return 0; 703 default: 704 return -EINVAL; 705 } 706 } 707 708 static const enum power_supply_property dell_wmi_ddv_properties[] = { 709 POWER_SUPPLY_PROP_TEMP, 710 }; 711 712 static const struct power_supply_ext dell_wmi_ddv_extension = { 713 .name = DRIVER_NAME, 714 .properties = dell_wmi_ddv_properties, 715 .num_properties = ARRAY_SIZE(dell_wmi_ddv_properties), 716 .get_property = dell_wmi_ddv_get_property, 717 }; 718 719 static int dell_wmi_ddv_add_battery(struct power_supply *battery, struct acpi_battery_hook *hook) 720 { 721 struct dell_wmi_ddv_data *data = container_of(hook, struct dell_wmi_ddv_data, hook); 722 u32 index; 723 int ret; 724 725 /* Return 0 instead of error to avoid being unloaded */ 726 ret = dell_wmi_ddv_battery_index(to_acpi_device(battery->dev.parent), &index); 727 if (ret < 0) 728 return 0; 729 730 ret = device_create_file(&battery->dev, &data->eppid_attr); 731 if (ret < 0) 732 return ret; 733 734 ret = power_supply_register_extension(battery, &dell_wmi_ddv_extension, &data->wdev->dev, 735 data); 736 if (ret < 0) { 737 device_remove_file(&battery->dev, &data->eppid_attr); 738 739 return ret; 740 } 741 742 return 0; 743 } 744 745 static int dell_wmi_ddv_remove_battery(struct power_supply *battery, struct acpi_battery_hook *hook) 746 { 747 struct dell_wmi_ddv_data *data = container_of(hook, struct dell_wmi_ddv_data, hook); 748 749 device_remove_file(&battery->dev, &data->eppid_attr); 750 power_supply_unregister_extension(battery, &dell_wmi_ddv_extension); 751 752 return 0; 753 } 754 755 static int dell_wmi_ddv_battery_add(struct dell_wmi_ddv_data *data) 756 { 757 data->hook.name = "Dell DDV Battery Extension"; 758 data->hook.add_battery = dell_wmi_ddv_add_battery; 759 data->hook.remove_battery = dell_wmi_ddv_remove_battery; 760 761 sysfs_attr_init(&data->eppid_attr.attr); 762 data->eppid_attr.attr.name = "eppid"; 763 data->eppid_attr.attr.mode = 0444; 764 data->eppid_attr.show = eppid_show; 765 766 return devm_battery_hook_register(&data->wdev->dev, &data->hook); 767 } 768 769 static int dell_wmi_ddv_buffer_read(struct seq_file *seq, enum dell_ddv_method method) 770 { 771 struct device *dev = seq->private; 772 struct dell_wmi_ddv_data *data = dev_get_drvdata(dev); 773 union acpi_object *obj; 774 u64 size; 775 u8 *buf; 776 int ret; 777 778 ret = dell_wmi_ddv_query_buffer(data->wdev, method, 0, &obj); 779 if (ret < 0) 780 return ret; 781 782 size = obj->package.elements[0].integer.value; 783 buf = obj->package.elements[1].buffer.pointer; 784 ret = seq_write(seq, buf, size); 785 kfree(obj); 786 787 return ret; 788 } 789 790 static int dell_wmi_ddv_fan_read(struct seq_file *seq, void *offset) 791 { 792 return dell_wmi_ddv_buffer_read(seq, DELL_DDV_FAN_SENSOR_INFORMATION); 793 } 794 795 static int dell_wmi_ddv_temp_read(struct seq_file *seq, void *offset) 796 { 797 return dell_wmi_ddv_buffer_read(seq, DELL_DDV_THERMAL_SENSOR_INFORMATION); 798 } 799 800 static void dell_wmi_ddv_debugfs_remove(void *data) 801 { 802 struct dentry *entry = data; 803 804 debugfs_remove(entry); 805 } 806 807 static void dell_wmi_ddv_debugfs_init(struct wmi_device *wdev) 808 { 809 struct dentry *entry; 810 char name[64]; 811 812 scnprintf(name, ARRAY_SIZE(name), "%s-%s", DRIVER_NAME, dev_name(&wdev->dev)); 813 entry = debugfs_create_dir(name, NULL); 814 815 debugfs_create_devm_seqfile(&wdev->dev, "fan_sensor_information", entry, 816 dell_wmi_ddv_fan_read); 817 debugfs_create_devm_seqfile(&wdev->dev, "thermal_sensor_information", entry, 818 dell_wmi_ddv_temp_read); 819 820 devm_add_action_or_reset(&wdev->dev, dell_wmi_ddv_debugfs_remove, entry); 821 } 822 823 static int dell_wmi_ddv_probe(struct wmi_device *wdev, const void *context) 824 { 825 struct dell_wmi_ddv_data *data; 826 u32 version; 827 int ret; 828 829 ret = dell_wmi_ddv_query_integer(wdev, DELL_DDV_INTERFACE_VERSION, 0, &version); 830 if (ret < 0) 831 return ret; 832 833 dev_dbg(&wdev->dev, "WMI interface version: %d\n", version); 834 if (version < DELL_DDV_SUPPORTED_VERSION_MIN || version > DELL_DDV_SUPPORTED_VERSION_MAX) { 835 if (!force) 836 return -ENODEV; 837 838 dev_warn(&wdev->dev, "Loading despite unsupported WMI interface version (%u)\n", 839 version); 840 } 841 842 data = devm_kzalloc(&wdev->dev, sizeof(*data), GFP_KERNEL); 843 if (!data) 844 return -ENOMEM; 845 846 dev_set_drvdata(&wdev->dev, data); 847 data->wdev = wdev; 848 849 dell_wmi_ddv_debugfs_init(wdev); 850 851 if (IS_REACHABLE(CONFIG_ACPI_BATTERY)) { 852 ret = dell_wmi_ddv_battery_add(data); 853 if (ret < 0) 854 dev_warn(&wdev->dev, "Unable to register ACPI battery hook: %d\n", ret); 855 } 856 857 if (IS_REACHABLE(CONFIG_HWMON)) { 858 ret = dell_wmi_ddv_hwmon_add(data); 859 if (ret < 0) 860 dev_warn(&wdev->dev, "Unable to register hwmon interface: %d\n", ret); 861 } 862 863 return 0; 864 } 865 866 static int dell_wmi_ddv_resume(struct device *dev) 867 { 868 struct dell_wmi_ddv_data *data = dev_get_drvdata(dev); 869 870 /* Force re-reading of all active sensors */ 871 dell_wmi_ddv_hwmon_cache_invalidate(&data->fans); 872 dell_wmi_ddv_hwmon_cache_invalidate(&data->temps); 873 874 return 0; 875 } 876 877 static DEFINE_SIMPLE_DEV_PM_OPS(dell_wmi_ddv_dev_pm_ops, NULL, dell_wmi_ddv_resume); 878 879 static const struct wmi_device_id dell_wmi_ddv_id_table[] = { 880 { DELL_DDV_GUID, NULL }, 881 { } 882 }; 883 MODULE_DEVICE_TABLE(wmi, dell_wmi_ddv_id_table); 884 885 static struct wmi_driver dell_wmi_ddv_driver = { 886 .driver = { 887 .name = DRIVER_NAME, 888 .probe_type = PROBE_PREFER_ASYNCHRONOUS, 889 .pm = pm_sleep_ptr(&dell_wmi_ddv_dev_pm_ops), 890 }, 891 .id_table = dell_wmi_ddv_id_table, 892 .probe = dell_wmi_ddv_probe, 893 .no_singleton = true, 894 }; 895 module_wmi_driver(dell_wmi_ddv_driver); 896 897 MODULE_AUTHOR("Armin Wolf <W_Armin@gmx.de>"); 898 MODULE_DESCRIPTION("Dell WMI sensor driver"); 899 MODULE_LICENSE("GPL"); 900