1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * A hwmon driver for ACPI 4.0 power meters 4 * Copyright (C) 2009 IBM 5 * 6 * Author: Darrick J. Wong <darrick.wong@oracle.com> 7 */ 8 9 #include <linux/module.h> 10 #include <linux/hwmon.h> 11 #include <linux/hwmon-sysfs.h> 12 #include <linux/jiffies.h> 13 #include <linux/mutex.h> 14 #include <linux/dmi.h> 15 #include <linux/slab.h> 16 #include <linux/kdev_t.h> 17 #include <linux/sched.h> 18 #include <linux/time.h> 19 #include <linux/err.h> 20 #include <linux/acpi.h> 21 22 #define ACPI_POWER_METER_NAME "power_meter" 23 ACPI_MODULE_NAME(ACPI_POWER_METER_NAME); 24 #define ACPI_POWER_METER_DEVICE_NAME "Power Meter" 25 #define ACPI_POWER_METER_CLASS "pwr_meter_resource" 26 27 #define NUM_SENSORS 17 28 29 #define POWER_METER_CAN_MEASURE (1 << 0) 30 #define POWER_METER_CAN_TRIP (1 << 1) 31 #define POWER_METER_CAN_CAP (1 << 2) 32 #define POWER_METER_CAN_NOTIFY (1 << 3) 33 #define POWER_METER_IS_BATTERY (1 << 8) 34 #define UNKNOWN_HYSTERESIS 0xFFFFFFFF 35 36 #define METER_NOTIFY_CONFIG 0x80 37 #define METER_NOTIFY_TRIP 0x81 38 #define METER_NOTIFY_CAP 0x82 39 #define METER_NOTIFY_CAPPING 0x83 40 #define METER_NOTIFY_INTERVAL 0x84 41 42 #define POWER_AVERAGE_NAME "power1_average" 43 #define POWER_CAP_NAME "power1_cap" 44 #define POWER_AVG_INTERVAL_NAME "power1_average_interval" 45 #define POWER_ALARM_NAME "power1_alarm" 46 47 static int cap_in_hardware; 48 static bool force_cap_on; 49 50 static int can_cap_in_hardware(void) 51 { 52 return force_cap_on || cap_in_hardware; 53 } 54 55 static const struct acpi_device_id power_meter_ids[] = { 56 {"ACPI000D", 0}, 57 {"", 0}, 58 }; 59 MODULE_DEVICE_TABLE(acpi, power_meter_ids); 60 61 struct acpi_power_meter_capabilities { 62 u64 flags; 63 u64 units; 64 u64 type; 65 u64 accuracy; 66 u64 sampling_time; 67 u64 min_avg_interval; 68 u64 max_avg_interval; 69 u64 hysteresis; 70 u64 configurable_cap; 71 u64 min_cap; 72 u64 max_cap; 73 }; 74 75 struct acpi_power_meter_resource { 76 struct acpi_device *acpi_dev; 77 acpi_bus_id name; 78 struct mutex lock; 79 struct device *hwmon_dev; 80 struct acpi_power_meter_capabilities caps; 81 acpi_string model_number; 82 acpi_string serial_number; 83 acpi_string oem_info; 84 u64 power; 85 u64 cap; 86 u64 avg_interval; 87 int sensors_valid; 88 unsigned long sensors_last_updated; 89 struct sensor_device_attribute sensors[NUM_SENSORS]; 90 int num_sensors; 91 s64 trip[2]; 92 int num_domain_devices; 93 struct acpi_device **domain_devices; 94 struct kobject *holders_dir; 95 }; 96 97 struct sensor_template { 98 char *label; 99 ssize_t (*show)(struct device *dev, 100 struct device_attribute *devattr, 101 char *buf); 102 ssize_t (*set)(struct device *dev, 103 struct device_attribute *devattr, 104 const char *buf, size_t count); 105 int index; 106 }; 107 108 /* Averaging interval */ 109 static int update_avg_interval(struct acpi_power_meter_resource *resource) 110 { 111 unsigned long long data; 112 acpi_status status; 113 114 status = acpi_evaluate_integer(resource->acpi_dev->handle, "_GAI", 115 NULL, &data); 116 if (ACPI_FAILURE(status)) { 117 ACPI_EXCEPTION((AE_INFO, status, "Evaluating _GAI")); 118 return -ENODEV; 119 } 120 121 resource->avg_interval = data; 122 return 0; 123 } 124 125 static ssize_t show_avg_interval(struct device *dev, 126 struct device_attribute *devattr, 127 char *buf) 128 { 129 struct acpi_device *acpi_dev = to_acpi_device(dev); 130 struct acpi_power_meter_resource *resource = acpi_dev->driver_data; 131 132 mutex_lock(&resource->lock); 133 update_avg_interval(resource); 134 mutex_unlock(&resource->lock); 135 136 return sprintf(buf, "%llu\n", resource->avg_interval); 137 } 138 139 static ssize_t set_avg_interval(struct device *dev, 140 struct device_attribute *devattr, 141 const char *buf, size_t count) 142 { 143 struct acpi_device *acpi_dev = to_acpi_device(dev); 144 struct acpi_power_meter_resource *resource = acpi_dev->driver_data; 145 union acpi_object arg0 = { ACPI_TYPE_INTEGER }; 146 struct acpi_object_list args = { 1, &arg0 }; 147 int res; 148 unsigned long temp; 149 unsigned long long data; 150 acpi_status status; 151 152 res = kstrtoul(buf, 10, &temp); 153 if (res) 154 return res; 155 156 if (temp > resource->caps.max_avg_interval || 157 temp < resource->caps.min_avg_interval) 158 return -EINVAL; 159 arg0.integer.value = temp; 160 161 mutex_lock(&resource->lock); 162 status = acpi_evaluate_integer(resource->acpi_dev->handle, "_PAI", 163 &args, &data); 164 if (!ACPI_FAILURE(status)) 165 resource->avg_interval = temp; 166 mutex_unlock(&resource->lock); 167 168 if (ACPI_FAILURE(status)) { 169 ACPI_EXCEPTION((AE_INFO, status, "Evaluating _PAI")); 170 return -EINVAL; 171 } 172 173 /* _PAI returns 0 on success, nonzero otherwise */ 174 if (data) 175 return -EINVAL; 176 177 return count; 178 } 179 180 /* Cap functions */ 181 static int update_cap(struct acpi_power_meter_resource *resource) 182 { 183 unsigned long long data; 184 acpi_status status; 185 186 status = acpi_evaluate_integer(resource->acpi_dev->handle, "_GHL", 187 NULL, &data); 188 if (ACPI_FAILURE(status)) { 189 ACPI_EXCEPTION((AE_INFO, status, "Evaluating _GHL")); 190 return -ENODEV; 191 } 192 193 resource->cap = data; 194 return 0; 195 } 196 197 static ssize_t show_cap(struct device *dev, 198 struct device_attribute *devattr, 199 char *buf) 200 { 201 struct acpi_device *acpi_dev = to_acpi_device(dev); 202 struct acpi_power_meter_resource *resource = acpi_dev->driver_data; 203 204 mutex_lock(&resource->lock); 205 update_cap(resource); 206 mutex_unlock(&resource->lock); 207 208 return sprintf(buf, "%llu\n", resource->cap * 1000); 209 } 210 211 static ssize_t set_cap(struct device *dev, struct device_attribute *devattr, 212 const char *buf, size_t count) 213 { 214 struct acpi_device *acpi_dev = to_acpi_device(dev); 215 struct acpi_power_meter_resource *resource = acpi_dev->driver_data; 216 union acpi_object arg0 = { ACPI_TYPE_INTEGER }; 217 struct acpi_object_list args = { 1, &arg0 }; 218 int res; 219 unsigned long temp; 220 unsigned long long data; 221 acpi_status status; 222 223 res = kstrtoul(buf, 10, &temp); 224 if (res) 225 return res; 226 227 temp = DIV_ROUND_CLOSEST(temp, 1000); 228 if (temp > resource->caps.max_cap || temp < resource->caps.min_cap) 229 return -EINVAL; 230 arg0.integer.value = temp; 231 232 mutex_lock(&resource->lock); 233 status = acpi_evaluate_integer(resource->acpi_dev->handle, "_SHL", 234 &args, &data); 235 if (!ACPI_FAILURE(status)) 236 resource->cap = temp; 237 mutex_unlock(&resource->lock); 238 239 if (ACPI_FAILURE(status)) { 240 ACPI_EXCEPTION((AE_INFO, status, "Evaluating _SHL")); 241 return -EINVAL; 242 } 243 244 /* _SHL returns 0 on success, nonzero otherwise */ 245 if (data) 246 return -EINVAL; 247 248 return count; 249 } 250 251 /* Power meter trip points */ 252 static int set_acpi_trip(struct acpi_power_meter_resource *resource) 253 { 254 union acpi_object arg_objs[] = { 255 {ACPI_TYPE_INTEGER}, 256 {ACPI_TYPE_INTEGER} 257 }; 258 struct acpi_object_list args = { 2, arg_objs }; 259 unsigned long long data; 260 acpi_status status; 261 262 /* Both trip levels must be set */ 263 if (resource->trip[0] < 0 || resource->trip[1] < 0) 264 return 0; 265 266 /* This driver stores min, max; ACPI wants max, min. */ 267 arg_objs[0].integer.value = resource->trip[1]; 268 arg_objs[1].integer.value = resource->trip[0]; 269 270 status = acpi_evaluate_integer(resource->acpi_dev->handle, "_PTP", 271 &args, &data); 272 if (ACPI_FAILURE(status)) { 273 ACPI_EXCEPTION((AE_INFO, status, "Evaluating _PTP")); 274 return -EINVAL; 275 } 276 277 /* _PTP returns 0 on success, nonzero otherwise */ 278 if (data) 279 return -EINVAL; 280 281 return 0; 282 } 283 284 static ssize_t set_trip(struct device *dev, struct device_attribute *devattr, 285 const char *buf, size_t count) 286 { 287 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 288 struct acpi_device *acpi_dev = to_acpi_device(dev); 289 struct acpi_power_meter_resource *resource = acpi_dev->driver_data; 290 int res; 291 unsigned long temp; 292 293 res = kstrtoul(buf, 10, &temp); 294 if (res) 295 return res; 296 297 temp = DIV_ROUND_CLOSEST(temp, 1000); 298 299 mutex_lock(&resource->lock); 300 resource->trip[attr->index - 7] = temp; 301 res = set_acpi_trip(resource); 302 mutex_unlock(&resource->lock); 303 304 if (res) 305 return res; 306 307 return count; 308 } 309 310 /* Power meter */ 311 static int update_meter(struct acpi_power_meter_resource *resource) 312 { 313 unsigned long long data; 314 acpi_status status; 315 unsigned long local_jiffies = jiffies; 316 317 if (time_before(local_jiffies, resource->sensors_last_updated + 318 msecs_to_jiffies(resource->caps.sampling_time)) && 319 resource->sensors_valid) 320 return 0; 321 322 status = acpi_evaluate_integer(resource->acpi_dev->handle, "_PMM", 323 NULL, &data); 324 if (ACPI_FAILURE(status)) { 325 ACPI_EXCEPTION((AE_INFO, status, "Evaluating _PMM")); 326 return -ENODEV; 327 } 328 329 resource->power = data; 330 resource->sensors_valid = 1; 331 resource->sensors_last_updated = jiffies; 332 return 0; 333 } 334 335 static ssize_t show_power(struct device *dev, 336 struct device_attribute *devattr, 337 char *buf) 338 { 339 struct acpi_device *acpi_dev = to_acpi_device(dev); 340 struct acpi_power_meter_resource *resource = acpi_dev->driver_data; 341 342 mutex_lock(&resource->lock); 343 update_meter(resource); 344 mutex_unlock(&resource->lock); 345 346 return sprintf(buf, "%llu\n", resource->power * 1000); 347 } 348 349 /* Miscellaneous */ 350 static ssize_t show_str(struct device *dev, 351 struct device_attribute *devattr, 352 char *buf) 353 { 354 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 355 struct acpi_device *acpi_dev = to_acpi_device(dev); 356 struct acpi_power_meter_resource *resource = acpi_dev->driver_data; 357 acpi_string val; 358 int ret; 359 360 mutex_lock(&resource->lock); 361 switch (attr->index) { 362 case 0: 363 val = resource->model_number; 364 break; 365 case 1: 366 val = resource->serial_number; 367 break; 368 case 2: 369 val = resource->oem_info; 370 break; 371 default: 372 WARN(1, "Implementation error: unexpected attribute index %d\n", 373 attr->index); 374 val = ""; 375 break; 376 } 377 ret = sprintf(buf, "%s\n", val); 378 mutex_unlock(&resource->lock); 379 return ret; 380 } 381 382 static ssize_t show_val(struct device *dev, 383 struct device_attribute *devattr, 384 char *buf) 385 { 386 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 387 struct acpi_device *acpi_dev = to_acpi_device(dev); 388 struct acpi_power_meter_resource *resource = acpi_dev->driver_data; 389 u64 val = 0; 390 391 switch (attr->index) { 392 case 0: 393 val = resource->caps.min_avg_interval; 394 break; 395 case 1: 396 val = resource->caps.max_avg_interval; 397 break; 398 case 2: 399 val = resource->caps.min_cap * 1000; 400 break; 401 case 3: 402 val = resource->caps.max_cap * 1000; 403 break; 404 case 4: 405 if (resource->caps.hysteresis == UNKNOWN_HYSTERESIS) 406 return sprintf(buf, "unknown\n"); 407 408 val = resource->caps.hysteresis * 1000; 409 break; 410 case 5: 411 if (resource->caps.flags & POWER_METER_IS_BATTERY) 412 val = 1; 413 else 414 val = 0; 415 break; 416 case 6: 417 if (resource->power > resource->cap) 418 val = 1; 419 else 420 val = 0; 421 break; 422 case 7: 423 case 8: 424 if (resource->trip[attr->index - 7] < 0) 425 return sprintf(buf, "unknown\n"); 426 427 val = resource->trip[attr->index - 7] * 1000; 428 break; 429 default: 430 WARN(1, "Implementation error: unexpected attribute index %d\n", 431 attr->index); 432 break; 433 } 434 435 return sprintf(buf, "%llu\n", val); 436 } 437 438 static ssize_t show_accuracy(struct device *dev, 439 struct device_attribute *devattr, 440 char *buf) 441 { 442 struct acpi_device *acpi_dev = to_acpi_device(dev); 443 struct acpi_power_meter_resource *resource = acpi_dev->driver_data; 444 unsigned int acc = resource->caps.accuracy; 445 446 return sprintf(buf, "%u.%u%%\n", acc / 1000, acc % 1000); 447 } 448 449 static ssize_t show_name(struct device *dev, 450 struct device_attribute *devattr, 451 char *buf) 452 { 453 return sprintf(buf, "%s\n", ACPI_POWER_METER_NAME); 454 } 455 456 #define RO_SENSOR_TEMPLATE(_label, _show, _index) \ 457 { \ 458 .label = _label, \ 459 .show = _show, \ 460 .index = _index, \ 461 } 462 463 #define RW_SENSOR_TEMPLATE(_label, _show, _set, _index) \ 464 { \ 465 .label = _label, \ 466 .show = _show, \ 467 .set = _set, \ 468 .index = _index, \ 469 } 470 471 /* Sensor descriptions. If you add a sensor, update NUM_SENSORS above! */ 472 static struct sensor_template meter_attrs[] = { 473 RO_SENSOR_TEMPLATE(POWER_AVERAGE_NAME, show_power, 0), 474 RO_SENSOR_TEMPLATE("power1_accuracy", show_accuracy, 0), 475 RO_SENSOR_TEMPLATE("power1_average_interval_min", show_val, 0), 476 RO_SENSOR_TEMPLATE("power1_average_interval_max", show_val, 1), 477 RO_SENSOR_TEMPLATE("power1_is_battery", show_val, 5), 478 RW_SENSOR_TEMPLATE(POWER_AVG_INTERVAL_NAME, show_avg_interval, 479 set_avg_interval, 0), 480 {}, 481 }; 482 483 static struct sensor_template misc_cap_attrs[] = { 484 RO_SENSOR_TEMPLATE("power1_cap_min", show_val, 2), 485 RO_SENSOR_TEMPLATE("power1_cap_max", show_val, 3), 486 RO_SENSOR_TEMPLATE("power1_cap_hyst", show_val, 4), 487 RO_SENSOR_TEMPLATE(POWER_ALARM_NAME, show_val, 6), 488 {}, 489 }; 490 491 static struct sensor_template ro_cap_attrs[] = { 492 RO_SENSOR_TEMPLATE(POWER_CAP_NAME, show_cap, 0), 493 {}, 494 }; 495 496 static struct sensor_template rw_cap_attrs[] = { 497 RW_SENSOR_TEMPLATE(POWER_CAP_NAME, show_cap, set_cap, 0), 498 {}, 499 }; 500 501 static struct sensor_template trip_attrs[] = { 502 RW_SENSOR_TEMPLATE("power1_average_min", show_val, set_trip, 7), 503 RW_SENSOR_TEMPLATE("power1_average_max", show_val, set_trip, 8), 504 {}, 505 }; 506 507 static struct sensor_template misc_attrs[] = { 508 RO_SENSOR_TEMPLATE("name", show_name, 0), 509 RO_SENSOR_TEMPLATE("power1_model_number", show_str, 0), 510 RO_SENSOR_TEMPLATE("power1_oem_info", show_str, 2), 511 RO_SENSOR_TEMPLATE("power1_serial_number", show_str, 1), 512 {}, 513 }; 514 515 #undef RO_SENSOR_TEMPLATE 516 #undef RW_SENSOR_TEMPLATE 517 518 /* Read power domain data */ 519 static void remove_domain_devices(struct acpi_power_meter_resource *resource) 520 { 521 int i; 522 523 if (!resource->num_domain_devices) 524 return; 525 526 for (i = 0; i < resource->num_domain_devices; i++) { 527 struct acpi_device *obj = resource->domain_devices[i]; 528 if (!obj) 529 continue; 530 531 sysfs_remove_link(resource->holders_dir, 532 kobject_name(&obj->dev.kobj)); 533 put_device(&obj->dev); 534 } 535 536 kfree(resource->domain_devices); 537 kobject_put(resource->holders_dir); 538 resource->num_domain_devices = 0; 539 } 540 541 static int read_domain_devices(struct acpi_power_meter_resource *resource) 542 { 543 int res = 0; 544 int i; 545 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL }; 546 union acpi_object *pss; 547 acpi_status status; 548 549 status = acpi_evaluate_object(resource->acpi_dev->handle, "_PMD", NULL, 550 &buffer); 551 if (ACPI_FAILURE(status)) { 552 ACPI_EXCEPTION((AE_INFO, status, "Evaluating _PMD")); 553 return -ENODEV; 554 } 555 556 pss = buffer.pointer; 557 if (!pss || 558 pss->type != ACPI_TYPE_PACKAGE) { 559 dev_err(&resource->acpi_dev->dev, ACPI_POWER_METER_NAME 560 "Invalid _PMD data\n"); 561 res = -EFAULT; 562 goto end; 563 } 564 565 if (!pss->package.count) 566 goto end; 567 568 resource->domain_devices = kcalloc(pss->package.count, 569 sizeof(struct acpi_device *), 570 GFP_KERNEL); 571 if (!resource->domain_devices) { 572 res = -ENOMEM; 573 goto end; 574 } 575 576 resource->holders_dir = kobject_create_and_add("measures", 577 &resource->acpi_dev->dev.kobj); 578 if (!resource->holders_dir) { 579 res = -ENOMEM; 580 goto exit_free; 581 } 582 583 resource->num_domain_devices = pss->package.count; 584 585 for (i = 0; i < pss->package.count; i++) { 586 struct acpi_device *obj; 587 union acpi_object *element = &(pss->package.elements[i]); 588 589 /* Refuse non-references */ 590 if (element->type != ACPI_TYPE_LOCAL_REFERENCE) 591 continue; 592 593 /* Create a symlink to domain objects */ 594 resource->domain_devices[i] = NULL; 595 if (acpi_bus_get_device(element->reference.handle, 596 &resource->domain_devices[i])) 597 continue; 598 599 obj = resource->domain_devices[i]; 600 get_device(&obj->dev); 601 602 res = sysfs_create_link(resource->holders_dir, &obj->dev.kobj, 603 kobject_name(&obj->dev.kobj)); 604 if (res) { 605 put_device(&obj->dev); 606 resource->domain_devices[i] = NULL; 607 } 608 } 609 610 res = 0; 611 goto end; 612 613 exit_free: 614 kfree(resource->domain_devices); 615 end: 616 kfree(buffer.pointer); 617 return res; 618 } 619 620 /* Registration and deregistration */ 621 static int register_attrs(struct acpi_power_meter_resource *resource, 622 struct sensor_template *attrs) 623 { 624 struct device *dev = &resource->acpi_dev->dev; 625 struct sensor_device_attribute *sensors = 626 &resource->sensors[resource->num_sensors]; 627 int res = 0; 628 629 while (attrs->label) { 630 sensors->dev_attr.attr.name = attrs->label; 631 sensors->dev_attr.attr.mode = 0444; 632 sensors->dev_attr.show = attrs->show; 633 sensors->index = attrs->index; 634 635 if (attrs->set) { 636 sensors->dev_attr.attr.mode |= 0200; 637 sensors->dev_attr.store = attrs->set; 638 } 639 640 sysfs_attr_init(&sensors->dev_attr.attr); 641 res = device_create_file(dev, &sensors->dev_attr); 642 if (res) { 643 sensors->dev_attr.attr.name = NULL; 644 goto error; 645 } 646 sensors++; 647 resource->num_sensors++; 648 attrs++; 649 } 650 651 error: 652 return res; 653 } 654 655 static void remove_attrs(struct acpi_power_meter_resource *resource) 656 { 657 int i; 658 659 for (i = 0; i < resource->num_sensors; i++) { 660 if (!resource->sensors[i].dev_attr.attr.name) 661 continue; 662 device_remove_file(&resource->acpi_dev->dev, 663 &resource->sensors[i].dev_attr); 664 } 665 666 remove_domain_devices(resource); 667 668 resource->num_sensors = 0; 669 } 670 671 static int setup_attrs(struct acpi_power_meter_resource *resource) 672 { 673 int res = 0; 674 675 res = read_domain_devices(resource); 676 if (res) 677 return res; 678 679 if (resource->caps.flags & POWER_METER_CAN_MEASURE) { 680 res = register_attrs(resource, meter_attrs); 681 if (res) 682 goto error; 683 } 684 685 if (resource->caps.flags & POWER_METER_CAN_CAP) { 686 if (!can_cap_in_hardware()) { 687 dev_warn(&resource->acpi_dev->dev, 688 "Ignoring unsafe software power cap!\n"); 689 goto skip_unsafe_cap; 690 } 691 692 if (resource->caps.configurable_cap) 693 res = register_attrs(resource, rw_cap_attrs); 694 else 695 res = register_attrs(resource, ro_cap_attrs); 696 697 if (res) 698 goto error; 699 700 res = register_attrs(resource, misc_cap_attrs); 701 if (res) 702 goto error; 703 } 704 705 skip_unsafe_cap: 706 if (resource->caps.flags & POWER_METER_CAN_TRIP) { 707 res = register_attrs(resource, trip_attrs); 708 if (res) 709 goto error; 710 } 711 712 res = register_attrs(resource, misc_attrs); 713 if (res) 714 goto error; 715 716 return res; 717 error: 718 remove_attrs(resource); 719 return res; 720 } 721 722 static void free_capabilities(struct acpi_power_meter_resource *resource) 723 { 724 acpi_string *str; 725 int i; 726 727 str = &resource->model_number; 728 for (i = 0; i < 3; i++, str++) 729 kfree(*str); 730 } 731 732 static int read_capabilities(struct acpi_power_meter_resource *resource) 733 { 734 int res = 0; 735 int i; 736 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL }; 737 struct acpi_buffer state = { 0, NULL }; 738 struct acpi_buffer format = { sizeof("NNNNNNNNNNN"), "NNNNNNNNNNN" }; 739 union acpi_object *pss; 740 acpi_string *str; 741 acpi_status status; 742 743 status = acpi_evaluate_object(resource->acpi_dev->handle, "_PMC", NULL, 744 &buffer); 745 if (ACPI_FAILURE(status)) { 746 ACPI_EXCEPTION((AE_INFO, status, "Evaluating _PMC")); 747 return -ENODEV; 748 } 749 750 pss = buffer.pointer; 751 if (!pss || 752 pss->type != ACPI_TYPE_PACKAGE || 753 pss->package.count != 14) { 754 dev_err(&resource->acpi_dev->dev, ACPI_POWER_METER_NAME 755 "Invalid _PMC data\n"); 756 res = -EFAULT; 757 goto end; 758 } 759 760 /* Grab all the integer data at once */ 761 state.length = sizeof(struct acpi_power_meter_capabilities); 762 state.pointer = &resource->caps; 763 764 status = acpi_extract_package(pss, &format, &state); 765 if (ACPI_FAILURE(status)) { 766 ACPI_EXCEPTION((AE_INFO, status, "Invalid data")); 767 res = -EFAULT; 768 goto end; 769 } 770 771 if (resource->caps.units) { 772 dev_err(&resource->acpi_dev->dev, ACPI_POWER_METER_NAME 773 "Unknown units %llu.\n", 774 resource->caps.units); 775 res = -EINVAL; 776 goto end; 777 } 778 779 /* Grab the string data */ 780 str = &resource->model_number; 781 782 for (i = 11; i < 14; i++) { 783 union acpi_object *element = &(pss->package.elements[i]); 784 785 if (element->type != ACPI_TYPE_STRING) { 786 res = -EINVAL; 787 goto error; 788 } 789 790 *str = kcalloc(element->string.length + 1, sizeof(u8), 791 GFP_KERNEL); 792 if (!*str) { 793 res = -ENOMEM; 794 goto error; 795 } 796 797 strncpy(*str, element->string.pointer, element->string.length); 798 str++; 799 } 800 801 dev_info(&resource->acpi_dev->dev, "Found ACPI power meter.\n"); 802 goto end; 803 error: 804 str = &resource->model_number; 805 for (i = 0; i < 3; i++, str++) 806 kfree(*str); 807 end: 808 kfree(buffer.pointer); 809 return res; 810 } 811 812 /* Handle ACPI event notifications */ 813 static void acpi_power_meter_notify(struct acpi_device *device, u32 event) 814 { 815 struct acpi_power_meter_resource *resource; 816 int res; 817 818 if (!device || !acpi_driver_data(device)) 819 return; 820 821 resource = acpi_driver_data(device); 822 823 switch (event) { 824 case METER_NOTIFY_CONFIG: 825 mutex_lock(&resource->lock); 826 free_capabilities(resource); 827 res = read_capabilities(resource); 828 mutex_unlock(&resource->lock); 829 if (res) 830 break; 831 832 remove_attrs(resource); 833 setup_attrs(resource); 834 break; 835 case METER_NOTIFY_TRIP: 836 sysfs_notify(&device->dev.kobj, NULL, POWER_AVERAGE_NAME); 837 break; 838 case METER_NOTIFY_CAP: 839 sysfs_notify(&device->dev.kobj, NULL, POWER_CAP_NAME); 840 break; 841 case METER_NOTIFY_INTERVAL: 842 sysfs_notify(&device->dev.kobj, NULL, POWER_AVG_INTERVAL_NAME); 843 break; 844 case METER_NOTIFY_CAPPING: 845 sysfs_notify(&device->dev.kobj, NULL, POWER_ALARM_NAME); 846 dev_info(&device->dev, "Capping in progress.\n"); 847 break; 848 default: 849 WARN(1, "Unexpected event %d\n", event); 850 break; 851 } 852 853 acpi_bus_generate_netlink_event(ACPI_POWER_METER_CLASS, 854 dev_name(&device->dev), event, 0); 855 } 856 857 static int acpi_power_meter_add(struct acpi_device *device) 858 { 859 int res; 860 struct acpi_power_meter_resource *resource; 861 862 if (!device) 863 return -EINVAL; 864 865 resource = kzalloc(sizeof(struct acpi_power_meter_resource), 866 GFP_KERNEL); 867 if (!resource) 868 return -ENOMEM; 869 870 resource->sensors_valid = 0; 871 resource->acpi_dev = device; 872 mutex_init(&resource->lock); 873 strcpy(acpi_device_name(device), ACPI_POWER_METER_DEVICE_NAME); 874 strcpy(acpi_device_class(device), ACPI_POWER_METER_CLASS); 875 device->driver_data = resource; 876 877 free_capabilities(resource); 878 res = read_capabilities(resource); 879 if (res) 880 goto exit_free; 881 882 resource->trip[0] = resource->trip[1] = -1; 883 884 res = setup_attrs(resource); 885 if (res) 886 goto exit_free; 887 888 resource->hwmon_dev = hwmon_device_register(&device->dev); 889 if (IS_ERR(resource->hwmon_dev)) { 890 res = PTR_ERR(resource->hwmon_dev); 891 goto exit_remove; 892 } 893 894 res = 0; 895 goto exit; 896 897 exit_remove: 898 remove_attrs(resource); 899 exit_free: 900 kfree(resource); 901 exit: 902 return res; 903 } 904 905 static int acpi_power_meter_remove(struct acpi_device *device) 906 { 907 struct acpi_power_meter_resource *resource; 908 909 if (!device || !acpi_driver_data(device)) 910 return -EINVAL; 911 912 resource = acpi_driver_data(device); 913 hwmon_device_unregister(resource->hwmon_dev); 914 915 remove_attrs(resource); 916 free_capabilities(resource); 917 918 kfree(resource); 919 return 0; 920 } 921 922 #ifdef CONFIG_PM_SLEEP 923 924 static int acpi_power_meter_resume(struct device *dev) 925 { 926 struct acpi_power_meter_resource *resource; 927 928 if (!dev) 929 return -EINVAL; 930 931 resource = acpi_driver_data(to_acpi_device(dev)); 932 if (!resource) 933 return -EINVAL; 934 935 free_capabilities(resource); 936 read_capabilities(resource); 937 938 return 0; 939 } 940 941 #endif /* CONFIG_PM_SLEEP */ 942 943 static SIMPLE_DEV_PM_OPS(acpi_power_meter_pm, NULL, acpi_power_meter_resume); 944 945 static struct acpi_driver acpi_power_meter_driver = { 946 .name = "power_meter", 947 .class = ACPI_POWER_METER_CLASS, 948 .ids = power_meter_ids, 949 .ops = { 950 .add = acpi_power_meter_add, 951 .remove = acpi_power_meter_remove, 952 .notify = acpi_power_meter_notify, 953 }, 954 .drv.pm = &acpi_power_meter_pm, 955 }; 956 957 /* Module init/exit routines */ 958 static int __init enable_cap_knobs(const struct dmi_system_id *d) 959 { 960 cap_in_hardware = 1; 961 return 0; 962 } 963 964 static const struct dmi_system_id pm_dmi_table[] __initconst = { 965 { 966 enable_cap_knobs, "IBM Active Energy Manager", 967 { 968 DMI_MATCH(DMI_SYS_VENDOR, "IBM") 969 }, 970 }, 971 {} 972 }; 973 974 static int __init acpi_power_meter_init(void) 975 { 976 int result; 977 978 if (acpi_disabled) 979 return -ENODEV; 980 981 dmi_check_system(pm_dmi_table); 982 983 result = acpi_bus_register_driver(&acpi_power_meter_driver); 984 if (result < 0) 985 return result; 986 987 return 0; 988 } 989 990 static void __exit acpi_power_meter_exit(void) 991 { 992 acpi_bus_unregister_driver(&acpi_power_meter_driver); 993 } 994 995 MODULE_AUTHOR("Darrick J. Wong <darrick.wong@oracle.com>"); 996 MODULE_DESCRIPTION("ACPI 4.0 power meter driver"); 997 MODULE_LICENSE("GPL"); 998 999 module_param(force_cap_on, bool, 0644); 1000 MODULE_PARM_DESC(force_cap_on, "Enable power cap even it is unsafe to do so."); 1001 1002 module_init(acpi_power_meter_init); 1003 module_exit(acpi_power_meter_exit); 1004