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