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