1 /* 2 * drivers/acpi/power.c - ACPI Power Resources management. 3 * 4 * Copyright (C) 2001 - 2015 Intel Corp. 5 * Author: Andy Grover <andrew.grover@intel.com> 6 * Author: Paul Diefenbaugh <paul.s.diefenbaugh@intel.com> 7 * Author: Rafael J. Wysocki <rafael.j.wysocki@intel.com> 8 * 9 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 10 * 11 * This program is free software; you can redistribute it and/or modify 12 * it under the terms of the GNU General Public License as published by 13 * the Free Software Foundation; either version 2 of the License, or (at 14 * your option) any later version. 15 * 16 * This program is distributed in the hope that it will be useful, but 17 * WITHOUT ANY WARRANTY; without even the implied warranty of 18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 19 * General Public License for more details. 20 * 21 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 22 */ 23 24 /* 25 * ACPI power-managed devices may be controlled in two ways: 26 * 1. via "Device Specific (D-State) Control" 27 * 2. via "Power Resource Control". 28 * The code below deals with ACPI Power Resources control. 29 * 30 * An ACPI "power resource object" represents a software controllable power 31 * plane, clock plane, or other resource depended on by a device. 32 * 33 * A device may rely on multiple power resources, and a power resource 34 * may be shared by multiple devices. 35 */ 36 37 #include <linux/kernel.h> 38 #include <linux/module.h> 39 #include <linux/init.h> 40 #include <linux/types.h> 41 #include <linux/slab.h> 42 #include <linux/pm_runtime.h> 43 #include <linux/sysfs.h> 44 #include <linux/acpi.h> 45 #include "sleep.h" 46 #include "internal.h" 47 48 #define _COMPONENT ACPI_POWER_COMPONENT 49 ACPI_MODULE_NAME("power"); 50 #define ACPI_POWER_CLASS "power_resource" 51 #define ACPI_POWER_DEVICE_NAME "Power Resource" 52 #define ACPI_POWER_FILE_INFO "info" 53 #define ACPI_POWER_FILE_STATUS "state" 54 #define ACPI_POWER_RESOURCE_STATE_OFF 0x00 55 #define ACPI_POWER_RESOURCE_STATE_ON 0x01 56 #define ACPI_POWER_RESOURCE_STATE_UNKNOWN 0xFF 57 58 struct acpi_power_resource { 59 struct acpi_device device; 60 struct list_head list_node; 61 char *name; 62 u32 system_level; 63 u32 order; 64 unsigned int ref_count; 65 bool wakeup_enabled; 66 struct mutex resource_lock; 67 }; 68 69 struct acpi_power_resource_entry { 70 struct list_head node; 71 struct acpi_power_resource *resource; 72 }; 73 74 static LIST_HEAD(acpi_power_resource_list); 75 static DEFINE_MUTEX(power_resource_list_lock); 76 77 /* -------------------------------------------------------------------------- 78 Power Resource Management 79 -------------------------------------------------------------------------- */ 80 81 static inline 82 struct acpi_power_resource *to_power_resource(struct acpi_device *device) 83 { 84 return container_of(device, struct acpi_power_resource, device); 85 } 86 87 static struct acpi_power_resource *acpi_power_get_context(acpi_handle handle) 88 { 89 struct acpi_device *device; 90 91 if (acpi_bus_get_device(handle, &device)) 92 return NULL; 93 94 return to_power_resource(device); 95 } 96 97 static int acpi_power_resources_list_add(acpi_handle handle, 98 struct list_head *list) 99 { 100 struct acpi_power_resource *resource = acpi_power_get_context(handle); 101 struct acpi_power_resource_entry *entry; 102 103 if (!resource || !list) 104 return -EINVAL; 105 106 entry = kzalloc(sizeof(*entry), GFP_KERNEL); 107 if (!entry) 108 return -ENOMEM; 109 110 entry->resource = resource; 111 if (!list_empty(list)) { 112 struct acpi_power_resource_entry *e; 113 114 list_for_each_entry(e, list, node) 115 if (e->resource->order > resource->order) { 116 list_add_tail(&entry->node, &e->node); 117 return 0; 118 } 119 } 120 list_add_tail(&entry->node, list); 121 return 0; 122 } 123 124 void acpi_power_resources_list_free(struct list_head *list) 125 { 126 struct acpi_power_resource_entry *entry, *e; 127 128 list_for_each_entry_safe(entry, e, list, node) { 129 list_del(&entry->node); 130 kfree(entry); 131 } 132 } 133 134 int acpi_extract_power_resources(union acpi_object *package, unsigned int start, 135 struct list_head *list) 136 { 137 unsigned int i; 138 int err = 0; 139 140 for (i = start; i < package->package.count; i++) { 141 union acpi_object *element = &package->package.elements[i]; 142 acpi_handle rhandle; 143 144 if (element->type != ACPI_TYPE_LOCAL_REFERENCE) { 145 err = -ENODATA; 146 break; 147 } 148 rhandle = element->reference.handle; 149 if (!rhandle) { 150 err = -ENODEV; 151 break; 152 } 153 err = acpi_add_power_resource(rhandle); 154 if (err) 155 break; 156 157 err = acpi_power_resources_list_add(rhandle, list); 158 if (err) 159 break; 160 } 161 if (err) 162 acpi_power_resources_list_free(list); 163 164 return err; 165 } 166 167 static int acpi_power_get_state(acpi_handle handle, int *state) 168 { 169 acpi_status status = AE_OK; 170 unsigned long long sta = 0; 171 char node_name[5]; 172 struct acpi_buffer buffer = { sizeof(node_name), node_name }; 173 174 175 if (!handle || !state) 176 return -EINVAL; 177 178 status = acpi_evaluate_integer(handle, "_STA", NULL, &sta); 179 if (ACPI_FAILURE(status)) 180 return -ENODEV; 181 182 *state = (sta & 0x01)?ACPI_POWER_RESOURCE_STATE_ON: 183 ACPI_POWER_RESOURCE_STATE_OFF; 184 185 acpi_get_name(handle, ACPI_SINGLE_NAME, &buffer); 186 187 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Resource [%s] is %s\n", 188 node_name, 189 *state ? "on" : "off")); 190 191 return 0; 192 } 193 194 static int acpi_power_get_list_state(struct list_head *list, int *state) 195 { 196 struct acpi_power_resource_entry *entry; 197 int cur_state; 198 199 if (!list || !state) 200 return -EINVAL; 201 202 /* The state of the list is 'on' IFF all resources are 'on'. */ 203 cur_state = 0; 204 list_for_each_entry(entry, list, node) { 205 struct acpi_power_resource *resource = entry->resource; 206 acpi_handle handle = resource->device.handle; 207 int result; 208 209 mutex_lock(&resource->resource_lock); 210 result = acpi_power_get_state(handle, &cur_state); 211 mutex_unlock(&resource->resource_lock); 212 if (result) 213 return result; 214 215 if (cur_state != ACPI_POWER_RESOURCE_STATE_ON) 216 break; 217 } 218 219 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Resource list is %s\n", 220 cur_state ? "on" : "off")); 221 222 *state = cur_state; 223 return 0; 224 } 225 226 static int __acpi_power_on(struct acpi_power_resource *resource) 227 { 228 acpi_status status = AE_OK; 229 230 status = acpi_evaluate_object(resource->device.handle, "_ON", NULL, NULL); 231 if (ACPI_FAILURE(status)) 232 return -ENODEV; 233 234 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Power resource [%s] turned on\n", 235 resource->name)); 236 237 return 0; 238 } 239 240 static int acpi_power_on_unlocked(struct acpi_power_resource *resource) 241 { 242 int result = 0; 243 244 if (resource->ref_count++) { 245 ACPI_DEBUG_PRINT((ACPI_DB_INFO, 246 "Power resource [%s] already on\n", 247 resource->name)); 248 } else { 249 result = __acpi_power_on(resource); 250 if (result) 251 resource->ref_count--; 252 } 253 return result; 254 } 255 256 static int acpi_power_on(struct acpi_power_resource *resource) 257 { 258 int result; 259 260 mutex_lock(&resource->resource_lock); 261 result = acpi_power_on_unlocked(resource); 262 mutex_unlock(&resource->resource_lock); 263 return result; 264 } 265 266 static int __acpi_power_off(struct acpi_power_resource *resource) 267 { 268 acpi_status status; 269 270 status = acpi_evaluate_object(resource->device.handle, "_OFF", 271 NULL, NULL); 272 if (ACPI_FAILURE(status)) 273 return -ENODEV; 274 275 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Power resource [%s] turned off\n", 276 resource->name)); 277 return 0; 278 } 279 280 static int acpi_power_off_unlocked(struct acpi_power_resource *resource) 281 { 282 int result = 0; 283 284 if (!resource->ref_count) { 285 ACPI_DEBUG_PRINT((ACPI_DB_INFO, 286 "Power resource [%s] already off\n", 287 resource->name)); 288 return 0; 289 } 290 291 if (--resource->ref_count) { 292 ACPI_DEBUG_PRINT((ACPI_DB_INFO, 293 "Power resource [%s] still in use\n", 294 resource->name)); 295 } else { 296 result = __acpi_power_off(resource); 297 if (result) 298 resource->ref_count++; 299 } 300 return result; 301 } 302 303 static int acpi_power_off(struct acpi_power_resource *resource) 304 { 305 int result; 306 307 mutex_lock(&resource->resource_lock); 308 result = acpi_power_off_unlocked(resource); 309 mutex_unlock(&resource->resource_lock); 310 return result; 311 } 312 313 static int acpi_power_off_list(struct list_head *list) 314 { 315 struct acpi_power_resource_entry *entry; 316 int result = 0; 317 318 list_for_each_entry_reverse(entry, list, node) { 319 result = acpi_power_off(entry->resource); 320 if (result) 321 goto err; 322 } 323 return 0; 324 325 err: 326 list_for_each_entry_continue(entry, list, node) 327 acpi_power_on(entry->resource); 328 329 return result; 330 } 331 332 static int acpi_power_on_list(struct list_head *list) 333 { 334 struct acpi_power_resource_entry *entry; 335 int result = 0; 336 337 list_for_each_entry(entry, list, node) { 338 result = acpi_power_on(entry->resource); 339 if (result) 340 goto err; 341 } 342 return 0; 343 344 err: 345 list_for_each_entry_continue_reverse(entry, list, node) 346 acpi_power_off(entry->resource); 347 348 return result; 349 } 350 351 static struct attribute *attrs[] = { 352 NULL, 353 }; 354 355 static struct attribute_group attr_groups[] = { 356 [ACPI_STATE_D0] = { 357 .name = "power_resources_D0", 358 .attrs = attrs, 359 }, 360 [ACPI_STATE_D1] = { 361 .name = "power_resources_D1", 362 .attrs = attrs, 363 }, 364 [ACPI_STATE_D2] = { 365 .name = "power_resources_D2", 366 .attrs = attrs, 367 }, 368 [ACPI_STATE_D3_HOT] = { 369 .name = "power_resources_D3hot", 370 .attrs = attrs, 371 }, 372 }; 373 374 static struct attribute_group wakeup_attr_group = { 375 .name = "power_resources_wakeup", 376 .attrs = attrs, 377 }; 378 379 static void acpi_power_hide_list(struct acpi_device *adev, 380 struct list_head *resources, 381 struct attribute_group *attr_group) 382 { 383 struct acpi_power_resource_entry *entry; 384 385 if (list_empty(resources)) 386 return; 387 388 list_for_each_entry_reverse(entry, resources, node) { 389 struct acpi_device *res_dev = &entry->resource->device; 390 391 sysfs_remove_link_from_group(&adev->dev.kobj, 392 attr_group->name, 393 dev_name(&res_dev->dev)); 394 } 395 sysfs_remove_group(&adev->dev.kobj, attr_group); 396 } 397 398 static void acpi_power_expose_list(struct acpi_device *adev, 399 struct list_head *resources, 400 struct attribute_group *attr_group) 401 { 402 struct acpi_power_resource_entry *entry; 403 int ret; 404 405 if (list_empty(resources)) 406 return; 407 408 ret = sysfs_create_group(&adev->dev.kobj, attr_group); 409 if (ret) 410 return; 411 412 list_for_each_entry(entry, resources, node) { 413 struct acpi_device *res_dev = &entry->resource->device; 414 415 ret = sysfs_add_link_to_group(&adev->dev.kobj, 416 attr_group->name, 417 &res_dev->dev.kobj, 418 dev_name(&res_dev->dev)); 419 if (ret) { 420 acpi_power_hide_list(adev, resources, attr_group); 421 break; 422 } 423 } 424 } 425 426 static void acpi_power_expose_hide(struct acpi_device *adev, 427 struct list_head *resources, 428 struct attribute_group *attr_group, 429 bool expose) 430 { 431 if (expose) 432 acpi_power_expose_list(adev, resources, attr_group); 433 else 434 acpi_power_hide_list(adev, resources, attr_group); 435 } 436 437 void acpi_power_add_remove_device(struct acpi_device *adev, bool add) 438 { 439 int state; 440 441 if (adev->wakeup.flags.valid) 442 acpi_power_expose_hide(adev, &adev->wakeup.resources, 443 &wakeup_attr_group, add); 444 445 if (!adev->power.flags.power_resources) 446 return; 447 448 for (state = ACPI_STATE_D0; state <= ACPI_STATE_D3_HOT; state++) 449 acpi_power_expose_hide(adev, 450 &adev->power.states[state].resources, 451 &attr_groups[state], add); 452 } 453 454 int acpi_power_wakeup_list_init(struct list_head *list, int *system_level_p) 455 { 456 struct acpi_power_resource_entry *entry; 457 int system_level = 5; 458 459 list_for_each_entry(entry, list, node) { 460 struct acpi_power_resource *resource = entry->resource; 461 acpi_handle handle = resource->device.handle; 462 int result; 463 int state; 464 465 mutex_lock(&resource->resource_lock); 466 467 result = acpi_power_get_state(handle, &state); 468 if (result) { 469 mutex_unlock(&resource->resource_lock); 470 return result; 471 } 472 if (state == ACPI_POWER_RESOURCE_STATE_ON) { 473 resource->ref_count++; 474 resource->wakeup_enabled = true; 475 } 476 if (system_level > resource->system_level) 477 system_level = resource->system_level; 478 479 mutex_unlock(&resource->resource_lock); 480 } 481 *system_level_p = system_level; 482 return 0; 483 } 484 485 /* -------------------------------------------------------------------------- 486 Device Power Management 487 -------------------------------------------------------------------------- */ 488 489 /** 490 * acpi_device_sleep_wake - execute _DSW (Device Sleep Wake) or (deprecated in 491 * ACPI 3.0) _PSW (Power State Wake) 492 * @dev: Device to handle. 493 * @enable: 0 - disable, 1 - enable the wake capabilities of the device. 494 * @sleep_state: Target sleep state of the system. 495 * @dev_state: Target power state of the device. 496 * 497 * Execute _DSW (Device Sleep Wake) or (deprecated in ACPI 3.0) _PSW (Power 498 * State Wake) for the device, if present. On failure reset the device's 499 * wakeup.flags.valid flag. 500 * 501 * RETURN VALUE: 502 * 0 if either _DSW or _PSW has been successfully executed 503 * 0 if neither _DSW nor _PSW has been found 504 * -ENODEV if the execution of either _DSW or _PSW has failed 505 */ 506 int acpi_device_sleep_wake(struct acpi_device *dev, 507 int enable, int sleep_state, int dev_state) 508 { 509 union acpi_object in_arg[3]; 510 struct acpi_object_list arg_list = { 3, in_arg }; 511 acpi_status status = AE_OK; 512 513 /* 514 * Try to execute _DSW first. 515 * 516 * Three agruments are needed for the _DSW object: 517 * Argument 0: enable/disable the wake capabilities 518 * Argument 1: target system state 519 * Argument 2: target device state 520 * When _DSW object is called to disable the wake capabilities, maybe 521 * the first argument is filled. The values of the other two agruments 522 * are meaningless. 523 */ 524 in_arg[0].type = ACPI_TYPE_INTEGER; 525 in_arg[0].integer.value = enable; 526 in_arg[1].type = ACPI_TYPE_INTEGER; 527 in_arg[1].integer.value = sleep_state; 528 in_arg[2].type = ACPI_TYPE_INTEGER; 529 in_arg[2].integer.value = dev_state; 530 status = acpi_evaluate_object(dev->handle, "_DSW", &arg_list, NULL); 531 if (ACPI_SUCCESS(status)) { 532 return 0; 533 } else if (status != AE_NOT_FOUND) { 534 printk(KERN_ERR PREFIX "_DSW execution failed\n"); 535 dev->wakeup.flags.valid = 0; 536 return -ENODEV; 537 } 538 539 /* Execute _PSW */ 540 status = acpi_execute_simple_method(dev->handle, "_PSW", enable); 541 if (ACPI_FAILURE(status) && (status != AE_NOT_FOUND)) { 542 printk(KERN_ERR PREFIX "_PSW execution failed\n"); 543 dev->wakeup.flags.valid = 0; 544 return -ENODEV; 545 } 546 547 return 0; 548 } 549 550 /* 551 * Prepare a wakeup device, two steps (Ref ACPI 2.0:P229): 552 * 1. Power on the power resources required for the wakeup device 553 * 2. Execute _DSW (Device Sleep Wake) or (deprecated in ACPI 3.0) _PSW (Power 554 * State Wake) for the device, if present 555 */ 556 int acpi_enable_wakeup_device_power(struct acpi_device *dev, int sleep_state) 557 { 558 struct acpi_power_resource_entry *entry; 559 int err = 0; 560 561 if (!dev || !dev->wakeup.flags.valid) 562 return -EINVAL; 563 564 mutex_lock(&acpi_device_lock); 565 566 if (dev->wakeup.prepare_count++) 567 goto out; 568 569 list_for_each_entry(entry, &dev->wakeup.resources, node) { 570 struct acpi_power_resource *resource = entry->resource; 571 572 mutex_lock(&resource->resource_lock); 573 574 if (!resource->wakeup_enabled) { 575 err = acpi_power_on_unlocked(resource); 576 if (!err) 577 resource->wakeup_enabled = true; 578 } 579 580 mutex_unlock(&resource->resource_lock); 581 582 if (err) { 583 dev_err(&dev->dev, 584 "Cannot turn wakeup power resources on\n"); 585 dev->wakeup.flags.valid = 0; 586 goto out; 587 } 588 } 589 /* 590 * Passing 3 as the third argument below means the device may be 591 * put into arbitrary power state afterward. 592 */ 593 err = acpi_device_sleep_wake(dev, 1, sleep_state, 3); 594 if (err) 595 dev->wakeup.prepare_count = 0; 596 597 out: 598 mutex_unlock(&acpi_device_lock); 599 return err; 600 } 601 602 /* 603 * Shutdown a wakeup device, counterpart of above method 604 * 1. Execute _DSW (Device Sleep Wake) or (deprecated in ACPI 3.0) _PSW (Power 605 * State Wake) for the device, if present 606 * 2. Shutdown down the power resources 607 */ 608 int acpi_disable_wakeup_device_power(struct acpi_device *dev) 609 { 610 struct acpi_power_resource_entry *entry; 611 int err = 0; 612 613 if (!dev || !dev->wakeup.flags.valid) 614 return -EINVAL; 615 616 mutex_lock(&acpi_device_lock); 617 618 if (--dev->wakeup.prepare_count > 0) 619 goto out; 620 621 /* 622 * Executing the code below even if prepare_count is already zero when 623 * the function is called may be useful, for example for initialisation. 624 */ 625 if (dev->wakeup.prepare_count < 0) 626 dev->wakeup.prepare_count = 0; 627 628 err = acpi_device_sleep_wake(dev, 0, 0, 0); 629 if (err) 630 goto out; 631 632 list_for_each_entry(entry, &dev->wakeup.resources, node) { 633 struct acpi_power_resource *resource = entry->resource; 634 635 mutex_lock(&resource->resource_lock); 636 637 if (resource->wakeup_enabled) { 638 err = acpi_power_off_unlocked(resource); 639 if (!err) 640 resource->wakeup_enabled = false; 641 } 642 643 mutex_unlock(&resource->resource_lock); 644 645 if (err) { 646 dev_err(&dev->dev, 647 "Cannot turn wakeup power resources off\n"); 648 dev->wakeup.flags.valid = 0; 649 break; 650 } 651 } 652 653 out: 654 mutex_unlock(&acpi_device_lock); 655 return err; 656 } 657 658 int acpi_power_get_inferred_state(struct acpi_device *device, int *state) 659 { 660 int result = 0; 661 int list_state = 0; 662 int i = 0; 663 664 if (!device || !state) 665 return -EINVAL; 666 667 /* 668 * We know a device's inferred power state when all the resources 669 * required for a given D-state are 'on'. 670 */ 671 for (i = ACPI_STATE_D0; i <= ACPI_STATE_D3_HOT; i++) { 672 struct list_head *list = &device->power.states[i].resources; 673 674 if (list_empty(list)) 675 continue; 676 677 result = acpi_power_get_list_state(list, &list_state); 678 if (result) 679 return result; 680 681 if (list_state == ACPI_POWER_RESOURCE_STATE_ON) { 682 *state = i; 683 return 0; 684 } 685 } 686 687 *state = device->power.states[ACPI_STATE_D3_COLD].flags.valid ? 688 ACPI_STATE_D3_COLD : ACPI_STATE_D3_HOT; 689 return 0; 690 } 691 692 int acpi_power_on_resources(struct acpi_device *device, int state) 693 { 694 if (!device || state < ACPI_STATE_D0 || state > ACPI_STATE_D3_HOT) 695 return -EINVAL; 696 697 return acpi_power_on_list(&device->power.states[state].resources); 698 } 699 700 int acpi_power_transition(struct acpi_device *device, int state) 701 { 702 int result = 0; 703 704 if (!device || (state < ACPI_STATE_D0) || (state > ACPI_STATE_D3_COLD)) 705 return -EINVAL; 706 707 if (device->power.state == state || !device->flags.power_manageable) 708 return 0; 709 710 if ((device->power.state < ACPI_STATE_D0) 711 || (device->power.state > ACPI_STATE_D3_COLD)) 712 return -ENODEV; 713 714 /* 715 * First we reference all power resources required in the target list 716 * (e.g. so the device doesn't lose power while transitioning). Then, 717 * we dereference all power resources used in the current list. 718 */ 719 if (state < ACPI_STATE_D3_COLD) 720 result = acpi_power_on_list( 721 &device->power.states[state].resources); 722 723 if (!result && device->power.state < ACPI_STATE_D3_COLD) 724 acpi_power_off_list( 725 &device->power.states[device->power.state].resources); 726 727 /* We shouldn't change the state unless the above operations succeed. */ 728 device->power.state = result ? ACPI_STATE_UNKNOWN : state; 729 730 return result; 731 } 732 733 static void acpi_release_power_resource(struct device *dev) 734 { 735 struct acpi_device *device = to_acpi_device(dev); 736 struct acpi_power_resource *resource; 737 738 resource = container_of(device, struct acpi_power_resource, device); 739 740 mutex_lock(&power_resource_list_lock); 741 list_del(&resource->list_node); 742 mutex_unlock(&power_resource_list_lock); 743 744 acpi_free_pnp_ids(&device->pnp); 745 kfree(resource); 746 } 747 748 static ssize_t acpi_power_in_use_show(struct device *dev, 749 struct device_attribute *attr, 750 char *buf) { 751 struct acpi_power_resource *resource; 752 753 resource = to_power_resource(to_acpi_device(dev)); 754 return sprintf(buf, "%u\n", !!resource->ref_count); 755 } 756 static DEVICE_ATTR(resource_in_use, 0444, acpi_power_in_use_show, NULL); 757 758 static void acpi_power_sysfs_remove(struct acpi_device *device) 759 { 760 device_remove_file(&device->dev, &dev_attr_resource_in_use); 761 } 762 763 static void acpi_power_add_resource_to_list(struct acpi_power_resource *resource) 764 { 765 mutex_lock(&power_resource_list_lock); 766 767 if (!list_empty(&acpi_power_resource_list)) { 768 struct acpi_power_resource *r; 769 770 list_for_each_entry(r, &acpi_power_resource_list, list_node) 771 if (r->order > resource->order) { 772 list_add_tail(&resource->list_node, &r->list_node); 773 goto out; 774 } 775 } 776 list_add_tail(&resource->list_node, &acpi_power_resource_list); 777 778 out: 779 mutex_unlock(&power_resource_list_lock); 780 } 781 782 int acpi_add_power_resource(acpi_handle handle) 783 { 784 struct acpi_power_resource *resource; 785 struct acpi_device *device = NULL; 786 union acpi_object acpi_object; 787 struct acpi_buffer buffer = { sizeof(acpi_object), &acpi_object }; 788 acpi_status status; 789 int state, result = -ENODEV; 790 791 acpi_bus_get_device(handle, &device); 792 if (device) 793 return 0; 794 795 resource = kzalloc(sizeof(*resource), GFP_KERNEL); 796 if (!resource) 797 return -ENOMEM; 798 799 device = &resource->device; 800 acpi_init_device_object(device, handle, ACPI_BUS_TYPE_POWER, 801 ACPI_STA_DEFAULT); 802 mutex_init(&resource->resource_lock); 803 INIT_LIST_HEAD(&resource->list_node); 804 resource->name = device->pnp.bus_id; 805 strcpy(acpi_device_name(device), ACPI_POWER_DEVICE_NAME); 806 strcpy(acpi_device_class(device), ACPI_POWER_CLASS); 807 device->power.state = ACPI_STATE_UNKNOWN; 808 809 /* Evalute the object to get the system level and resource order. */ 810 status = acpi_evaluate_object(handle, NULL, NULL, &buffer); 811 if (ACPI_FAILURE(status)) 812 goto err; 813 814 resource->system_level = acpi_object.power_resource.system_level; 815 resource->order = acpi_object.power_resource.resource_order; 816 817 result = acpi_power_get_state(handle, &state); 818 if (result) 819 goto err; 820 821 printk(KERN_INFO PREFIX "%s [%s] (%s)\n", acpi_device_name(device), 822 acpi_device_bid(device), state ? "on" : "off"); 823 824 device->flags.match_driver = true; 825 result = acpi_device_add(device, acpi_release_power_resource); 826 if (result) 827 goto err; 828 829 if (!device_create_file(&device->dev, &dev_attr_resource_in_use)) 830 device->remove = acpi_power_sysfs_remove; 831 832 acpi_power_add_resource_to_list(resource); 833 acpi_device_add_finalize(device); 834 return 0; 835 836 err: 837 acpi_release_power_resource(&device->dev); 838 return result; 839 } 840 841 #ifdef CONFIG_ACPI_SLEEP 842 void acpi_resume_power_resources(void) 843 { 844 struct acpi_power_resource *resource; 845 846 mutex_lock(&power_resource_list_lock); 847 848 list_for_each_entry(resource, &acpi_power_resource_list, list_node) { 849 int result, state; 850 851 mutex_lock(&resource->resource_lock); 852 853 result = acpi_power_get_state(resource->device.handle, &state); 854 if (result) { 855 mutex_unlock(&resource->resource_lock); 856 continue; 857 } 858 859 if (state == ACPI_POWER_RESOURCE_STATE_OFF 860 && resource->ref_count) { 861 dev_info(&resource->device.dev, "Turning ON\n"); 862 __acpi_power_on(resource); 863 } 864 865 mutex_unlock(&resource->resource_lock); 866 } 867 list_for_each_entry_reverse(resource, &acpi_power_resource_list, list_node) { 868 int result, state; 869 870 mutex_lock(&resource->resource_lock); 871 872 result = acpi_power_get_state(resource->device.handle, &state); 873 if (result) { 874 mutex_unlock(&resource->resource_lock); 875 continue; 876 } 877 878 if (state == ACPI_POWER_RESOURCE_STATE_ON 879 && !resource->ref_count) { 880 dev_info(&resource->device.dev, "Turning OFF\n"); 881 __acpi_power_off(resource); 882 } 883 884 mutex_unlock(&resource->resource_lock); 885 } 886 887 mutex_unlock(&power_resource_list_lock); 888 } 889 #endif 890