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