1 /* 2 * A hwmon driver for ACPI 4.0 power meters 3 * Copyright (C) 2009 IBM 4 * 5 * Author: Darrick J. Wong <djwong@us.ibm.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 <acpi/acpi_drivers.h> 33 #include <acpi/acpi_bus.h> 34 35 #define ACPI_POWER_METER_NAME "power_meter" 36 ACPI_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 60 static int cap_in_hardware; 61 static bool force_cap_on; 62 63 static int can_cap_in_hardware(void) 64 { 65 return force_cap_on || cap_in_hardware; 66 } 67 68 static const struct acpi_device_id power_meter_ids[] = { 69 {"ACPI000D", 0}, 70 {"", 0}, 71 }; 72 MODULE_DEVICE_TABLE(acpi, power_meter_ids); 73 74 struct 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 88 struct 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 110 struct 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 */ 122 static 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 138 static 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 152 static 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 */ 194 static 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 210 static 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 224 static 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 */ 265 static 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 297 static 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 */ 324 static 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 348 static 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 */ 363 static 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 BUG(); 384 val = ""; 385 } 386 387 return sprintf(buf, "%s\n", val); 388 } 389 390 static ssize_t show_val(struct device *dev, 391 struct device_attribute *devattr, 392 char *buf) 393 { 394 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 395 struct acpi_device *acpi_dev = to_acpi_device(dev); 396 struct acpi_power_meter_resource *resource = acpi_dev->driver_data; 397 u64 val = 0; 398 399 switch (attr->index) { 400 case 0: 401 val = resource->caps.min_avg_interval; 402 break; 403 case 1: 404 val = resource->caps.max_avg_interval; 405 break; 406 case 2: 407 val = resource->caps.min_cap * 1000; 408 break; 409 case 3: 410 val = resource->caps.max_cap * 1000; 411 break; 412 case 4: 413 if (resource->caps.hysteresis == UNKNOWN_HYSTERESIS) 414 return sprintf(buf, "unknown\n"); 415 416 val = resource->caps.hysteresis * 1000; 417 break; 418 case 5: 419 if (resource->caps.flags & POWER_METER_IS_BATTERY) 420 val = 1; 421 else 422 val = 0; 423 break; 424 case 6: 425 if (resource->power > resource->cap) 426 val = 1; 427 else 428 val = 0; 429 break; 430 case 7: 431 case 8: 432 if (resource->trip[attr->index - 7] < 0) 433 return sprintf(buf, "unknown\n"); 434 435 val = resource->trip[attr->index - 7] * 1000; 436 break; 437 default: 438 BUG(); 439 } 440 441 return sprintf(buf, "%llu\n", val); 442 } 443 444 static ssize_t show_accuracy(struct device *dev, 445 struct device_attribute *devattr, 446 char *buf) 447 { 448 struct acpi_device *acpi_dev = to_acpi_device(dev); 449 struct acpi_power_meter_resource *resource = acpi_dev->driver_data; 450 unsigned int acc = resource->caps.accuracy; 451 452 return sprintf(buf, "%u.%u%%\n", acc / 1000, acc % 1000); 453 } 454 455 static ssize_t show_name(struct device *dev, 456 struct device_attribute *devattr, 457 char *buf) 458 { 459 return sprintf(buf, "%s\n", ACPI_POWER_METER_NAME); 460 } 461 462 #define RO_SENSOR_TEMPLATE(_label, _show, _index) \ 463 { \ 464 .label = _label, \ 465 .show = _show, \ 466 .index = _index, \ 467 } 468 469 #define RW_SENSOR_TEMPLATE(_label, _show, _set, _index) \ 470 { \ 471 .label = _label, \ 472 .show = _show, \ 473 .set = _set, \ 474 .index = _index, \ 475 } 476 477 /* Sensor descriptions. If you add a sensor, update NUM_SENSORS above! */ 478 static struct sensor_template meter_attrs[] = { 479 RO_SENSOR_TEMPLATE(POWER_AVERAGE_NAME, show_power, 0), 480 RO_SENSOR_TEMPLATE("power1_accuracy", show_accuracy, 0), 481 RO_SENSOR_TEMPLATE("power1_average_interval_min", show_val, 0), 482 RO_SENSOR_TEMPLATE("power1_average_interval_max", show_val, 1), 483 RO_SENSOR_TEMPLATE("power1_is_battery", show_val, 5), 484 RW_SENSOR_TEMPLATE(POWER_AVG_INTERVAL_NAME, show_avg_interval, 485 set_avg_interval, 0), 486 {}, 487 }; 488 489 static struct sensor_template misc_cap_attrs[] = { 490 RO_SENSOR_TEMPLATE("power1_cap_min", show_val, 2), 491 RO_SENSOR_TEMPLATE("power1_cap_max", show_val, 3), 492 RO_SENSOR_TEMPLATE("power1_cap_hyst", show_val, 4), 493 RO_SENSOR_TEMPLATE(POWER_ALARM_NAME, show_val, 6), 494 {}, 495 }; 496 497 static struct sensor_template ro_cap_attrs[] = { 498 RO_SENSOR_TEMPLATE(POWER_CAP_NAME, show_cap, 0), 499 {}, 500 }; 501 502 static struct sensor_template rw_cap_attrs[] = { 503 RW_SENSOR_TEMPLATE(POWER_CAP_NAME, show_cap, set_cap, 0), 504 {}, 505 }; 506 507 static struct sensor_template trip_attrs[] = { 508 RW_SENSOR_TEMPLATE("power1_average_min", show_val, set_trip, 7), 509 RW_SENSOR_TEMPLATE("power1_average_max", show_val, set_trip, 8), 510 {}, 511 }; 512 513 static struct sensor_template misc_attrs[] = { 514 RO_SENSOR_TEMPLATE("name", show_name, 0), 515 RO_SENSOR_TEMPLATE("power1_model_number", show_str, 0), 516 RO_SENSOR_TEMPLATE("power1_oem_info", show_str, 2), 517 RO_SENSOR_TEMPLATE("power1_serial_number", show_str, 1), 518 {}, 519 }; 520 521 #undef RO_SENSOR_TEMPLATE 522 #undef RW_SENSOR_TEMPLATE 523 524 /* Read power domain data */ 525 static void remove_domain_devices(struct acpi_power_meter_resource *resource) 526 { 527 int i; 528 529 if (!resource->num_domain_devices) 530 return; 531 532 for (i = 0; i < resource->num_domain_devices; i++) { 533 struct acpi_device *obj = resource->domain_devices[i]; 534 if (!obj) 535 continue; 536 537 sysfs_remove_link(resource->holders_dir, 538 kobject_name(&obj->dev.kobj)); 539 put_device(&obj->dev); 540 } 541 542 kfree(resource->domain_devices); 543 kobject_put(resource->holders_dir); 544 resource->num_domain_devices = 0; 545 } 546 547 static int read_domain_devices(struct acpi_power_meter_resource *resource) 548 { 549 int res = 0; 550 int i; 551 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL }; 552 union acpi_object *pss; 553 acpi_status status; 554 555 status = acpi_evaluate_object(resource->acpi_dev->handle, "_PMD", NULL, 556 &buffer); 557 if (ACPI_FAILURE(status)) { 558 ACPI_EXCEPTION((AE_INFO, status, "Evaluating _PMD")); 559 return -ENODEV; 560 } 561 562 pss = buffer.pointer; 563 if (!pss || 564 pss->type != ACPI_TYPE_PACKAGE) { 565 dev_err(&resource->acpi_dev->dev, ACPI_POWER_METER_NAME 566 "Invalid _PMD data\n"); 567 res = -EFAULT; 568 goto end; 569 } 570 571 if (!pss->package.count) 572 goto end; 573 574 resource->domain_devices = kzalloc(sizeof(struct acpi_device *) * 575 pss->package.count, GFP_KERNEL); 576 if (!resource->domain_devices) { 577 res = -ENOMEM; 578 goto end; 579 } 580 581 resource->holders_dir = kobject_create_and_add("measures", 582 &resource->acpi_dev->dev.kobj); 583 if (!resource->holders_dir) { 584 res = -ENOMEM; 585 goto exit_free; 586 } 587 588 resource->num_domain_devices = pss->package.count; 589 590 for (i = 0; i < pss->package.count; i++) { 591 struct acpi_device *obj; 592 union acpi_object *element = &(pss->package.elements[i]); 593 594 /* Refuse non-references */ 595 if (element->type != ACPI_TYPE_LOCAL_REFERENCE) 596 continue; 597 598 /* Create a symlink to domain objects */ 599 resource->domain_devices[i] = NULL; 600 status = acpi_bus_get_device(element->reference.handle, 601 &resource->domain_devices[i]); 602 if (ACPI_FAILURE(status)) 603 continue; 604 605 obj = resource->domain_devices[i]; 606 get_device(&obj->dev); 607 608 res = sysfs_create_link(resource->holders_dir, &obj->dev.kobj, 609 kobject_name(&obj->dev.kobj)); 610 if (res) { 611 put_device(&obj->dev); 612 resource->domain_devices[i] = NULL; 613 } 614 } 615 616 res = 0; 617 goto end; 618 619 exit_free: 620 kfree(resource->domain_devices); 621 end: 622 kfree(buffer.pointer); 623 return res; 624 } 625 626 /* Registration and deregistration */ 627 static int register_attrs(struct acpi_power_meter_resource *resource, 628 struct sensor_template *attrs) 629 { 630 struct device *dev = &resource->acpi_dev->dev; 631 struct sensor_device_attribute *sensors = 632 &resource->sensors[resource->num_sensors]; 633 int res = 0; 634 635 while (attrs->label) { 636 sensors->dev_attr.attr.name = attrs->label; 637 sensors->dev_attr.attr.mode = S_IRUGO; 638 sensors->dev_attr.show = attrs->show; 639 sensors->index = attrs->index; 640 641 if (attrs->set) { 642 sensors->dev_attr.attr.mode |= S_IWUSR; 643 sensors->dev_attr.store = attrs->set; 644 } 645 646 sysfs_attr_init(&sensors->dev_attr.attr); 647 res = device_create_file(dev, &sensors->dev_attr); 648 if (res) { 649 sensors->dev_attr.attr.name = NULL; 650 goto error; 651 } 652 sensors++; 653 resource->num_sensors++; 654 attrs++; 655 } 656 657 error: 658 return res; 659 } 660 661 static void remove_attrs(struct acpi_power_meter_resource *resource) 662 { 663 int i; 664 665 for (i = 0; i < resource->num_sensors; i++) { 666 if (!resource->sensors[i].dev_attr.attr.name) 667 continue; 668 device_remove_file(&resource->acpi_dev->dev, 669 &resource->sensors[i].dev_attr); 670 } 671 672 remove_domain_devices(resource); 673 674 resource->num_sensors = 0; 675 } 676 677 static int setup_attrs(struct acpi_power_meter_resource *resource) 678 { 679 int res = 0; 680 681 res = read_domain_devices(resource); 682 if (res) 683 return res; 684 685 if (resource->caps.flags & POWER_METER_CAN_MEASURE) { 686 res = register_attrs(resource, meter_attrs); 687 if (res) 688 goto error; 689 } 690 691 if (resource->caps.flags & POWER_METER_CAN_CAP) { 692 if (!can_cap_in_hardware()) { 693 dev_err(&resource->acpi_dev->dev, 694 "Ignoring unsafe software power cap!\n"); 695 goto skip_unsafe_cap; 696 } 697 698 if (resource->caps.configurable_cap) 699 res = register_attrs(resource, rw_cap_attrs); 700 else 701 res = register_attrs(resource, ro_cap_attrs); 702 703 if (res) 704 goto error; 705 706 res = register_attrs(resource, misc_cap_attrs); 707 if (res) 708 goto error; 709 } 710 711 skip_unsafe_cap: 712 if (resource->caps.flags & POWER_METER_CAN_TRIP) { 713 res = register_attrs(resource, trip_attrs); 714 if (res) 715 goto error; 716 } 717 718 res = register_attrs(resource, misc_attrs); 719 if (res) 720 goto error; 721 722 return res; 723 error: 724 remove_attrs(resource); 725 return res; 726 } 727 728 static void free_capabilities(struct acpi_power_meter_resource *resource) 729 { 730 acpi_string *str; 731 int i; 732 733 str = &resource->model_number; 734 for (i = 0; i < 3; i++, str++) 735 kfree(*str); 736 } 737 738 static int read_capabilities(struct acpi_power_meter_resource *resource) 739 { 740 int res = 0; 741 int i; 742 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL }; 743 struct acpi_buffer state = { 0, NULL }; 744 struct acpi_buffer format = { sizeof("NNNNNNNNNNN"), "NNNNNNNNNNN" }; 745 union acpi_object *pss; 746 acpi_string *str; 747 acpi_status status; 748 749 status = acpi_evaluate_object(resource->acpi_dev->handle, "_PMC", NULL, 750 &buffer); 751 if (ACPI_FAILURE(status)) { 752 ACPI_EXCEPTION((AE_INFO, status, "Evaluating _PMC")); 753 return -ENODEV; 754 } 755 756 pss = buffer.pointer; 757 if (!pss || 758 pss->type != ACPI_TYPE_PACKAGE || 759 pss->package.count != 14) { 760 dev_err(&resource->acpi_dev->dev, ACPI_POWER_METER_NAME 761 "Invalid _PMC data\n"); 762 res = -EFAULT; 763 goto end; 764 } 765 766 /* Grab all the integer data at once */ 767 state.length = sizeof(struct acpi_power_meter_capabilities); 768 state.pointer = &resource->caps; 769 770 status = acpi_extract_package(pss, &format, &state); 771 if (ACPI_FAILURE(status)) { 772 ACPI_EXCEPTION((AE_INFO, status, "Invalid data")); 773 res = -EFAULT; 774 goto end; 775 } 776 777 if (resource->caps.units) { 778 dev_err(&resource->acpi_dev->dev, ACPI_POWER_METER_NAME 779 "Unknown units %llu.\n", 780 resource->caps.units); 781 res = -EINVAL; 782 goto end; 783 } 784 785 /* Grab the string data */ 786 str = &resource->model_number; 787 788 for (i = 11; i < 14; i++) { 789 union acpi_object *element = &(pss->package.elements[i]); 790 791 if (element->type != ACPI_TYPE_STRING) { 792 res = -EINVAL; 793 goto error; 794 } 795 796 *str = kzalloc(sizeof(u8) * (element->string.length + 1), 797 GFP_KERNEL); 798 if (!*str) { 799 res = -ENOMEM; 800 goto error; 801 } 802 803 strncpy(*str, element->string.pointer, element->string.length); 804 str++; 805 } 806 807 dev_info(&resource->acpi_dev->dev, "Found ACPI power meter.\n"); 808 goto end; 809 error: 810 str = &resource->model_number; 811 for (i = 0; i < 3; i++, str++) 812 kfree(*str); 813 end: 814 kfree(buffer.pointer); 815 return res; 816 } 817 818 /* Handle ACPI event notifications */ 819 static void acpi_power_meter_notify(struct acpi_device *device, u32 event) 820 { 821 struct acpi_power_meter_resource *resource; 822 int res; 823 824 if (!device || !acpi_driver_data(device)) 825 return; 826 827 resource = acpi_driver_data(device); 828 829 mutex_lock(&resource->lock); 830 switch (event) { 831 case METER_NOTIFY_CONFIG: 832 free_capabilities(resource); 833 res = read_capabilities(resource); 834 if (res) 835 break; 836 837 remove_attrs(resource); 838 setup_attrs(resource); 839 break; 840 case METER_NOTIFY_TRIP: 841 sysfs_notify(&device->dev.kobj, NULL, POWER_AVERAGE_NAME); 842 update_meter(resource); 843 break; 844 case METER_NOTIFY_CAP: 845 sysfs_notify(&device->dev.kobj, NULL, POWER_CAP_NAME); 846 update_cap(resource); 847 break; 848 case METER_NOTIFY_INTERVAL: 849 sysfs_notify(&device->dev.kobj, NULL, POWER_AVG_INTERVAL_NAME); 850 update_avg_interval(resource); 851 break; 852 case METER_NOTIFY_CAPPING: 853 sysfs_notify(&device->dev.kobj, NULL, POWER_ALARM_NAME); 854 dev_info(&device->dev, "Capping in progress.\n"); 855 break; 856 default: 857 BUG(); 858 } 859 mutex_unlock(&resource->lock); 860 861 acpi_bus_generate_netlink_event(ACPI_POWER_METER_CLASS, 862 dev_name(&device->dev), event, 0); 863 } 864 865 static int acpi_power_meter_add(struct acpi_device *device) 866 { 867 int res; 868 struct acpi_power_meter_resource *resource; 869 870 if (!device) 871 return -EINVAL; 872 873 resource = kzalloc(sizeof(struct acpi_power_meter_resource), 874 GFP_KERNEL); 875 if (!resource) 876 return -ENOMEM; 877 878 resource->sensors_valid = 0; 879 resource->acpi_dev = device; 880 mutex_init(&resource->lock); 881 strcpy(acpi_device_name(device), ACPI_POWER_METER_DEVICE_NAME); 882 strcpy(acpi_device_class(device), ACPI_POWER_METER_CLASS); 883 device->driver_data = resource; 884 885 free_capabilities(resource); 886 res = read_capabilities(resource); 887 if (res) 888 goto exit_free; 889 890 resource->trip[0] = resource->trip[1] = -1; 891 892 res = setup_attrs(resource); 893 if (res) 894 goto exit_free; 895 896 resource->hwmon_dev = hwmon_device_register(&device->dev); 897 if (IS_ERR(resource->hwmon_dev)) { 898 res = PTR_ERR(resource->hwmon_dev); 899 goto exit_remove; 900 } 901 902 res = 0; 903 goto exit; 904 905 exit_remove: 906 remove_attrs(resource); 907 exit_free: 908 kfree(resource); 909 exit: 910 return res; 911 } 912 913 static int acpi_power_meter_remove(struct acpi_device *device, int type) 914 { 915 struct acpi_power_meter_resource *resource; 916 917 if (!device || !acpi_driver_data(device)) 918 return -EINVAL; 919 920 resource = acpi_driver_data(device); 921 hwmon_device_unregister(resource->hwmon_dev); 922 923 free_capabilities(resource); 924 remove_attrs(resource); 925 926 kfree(resource); 927 return 0; 928 } 929 930 #ifdef CONFIG_PM_SLEEP 931 932 static int acpi_power_meter_resume(struct device *dev) 933 { 934 struct acpi_power_meter_resource *resource; 935 936 if (!dev) 937 return -EINVAL; 938 939 resource = acpi_driver_data(to_acpi_device(dev)); 940 if (!resource) 941 return -EINVAL; 942 943 free_capabilities(resource); 944 read_capabilities(resource); 945 946 return 0; 947 } 948 949 #endif /* CONFIG_PM_SLEEP */ 950 951 static SIMPLE_DEV_PM_OPS(acpi_power_meter_pm, NULL, acpi_power_meter_resume); 952 953 static struct acpi_driver acpi_power_meter_driver = { 954 .name = "power_meter", 955 .class = ACPI_POWER_METER_CLASS, 956 .ids = power_meter_ids, 957 .ops = { 958 .add = acpi_power_meter_add, 959 .remove = acpi_power_meter_remove, 960 .notify = acpi_power_meter_notify, 961 }, 962 .drv.pm = &acpi_power_meter_pm, 963 }; 964 965 /* Module init/exit routines */ 966 static int __init enable_cap_knobs(const struct dmi_system_id *d) 967 { 968 cap_in_hardware = 1; 969 return 0; 970 } 971 972 static struct dmi_system_id __initdata pm_dmi_table[] = { 973 { 974 enable_cap_knobs, "IBM Active Energy Manager", 975 { 976 DMI_MATCH(DMI_SYS_VENDOR, "IBM") 977 }, 978 }, 979 {} 980 }; 981 982 static int __init acpi_power_meter_init(void) 983 { 984 int result; 985 986 if (acpi_disabled) 987 return -ENODEV; 988 989 dmi_check_system(pm_dmi_table); 990 991 result = acpi_bus_register_driver(&acpi_power_meter_driver); 992 if (result < 0) 993 return -ENODEV; 994 995 return 0; 996 } 997 998 static void __exit acpi_power_meter_exit(void) 999 { 1000 acpi_bus_unregister_driver(&acpi_power_meter_driver); 1001 } 1002 1003 MODULE_AUTHOR("Darrick J. Wong <djwong@us.ibm.com>"); 1004 MODULE_DESCRIPTION("ACPI 4.0 power meter driver"); 1005 MODULE_LICENSE("GPL"); 1006 1007 module_param(force_cap_on, bool, 0644); 1008 MODULE_PARM_DESC(force_cap_on, "Enable power cap even it is unsafe to do so."); 1009 1010 module_init(acpi_power_meter_init); 1011 module_exit(acpi_power_meter_exit); 1012