1/* 2 * acpi_power.c - ACPI Bus Power Management ($Revision: 39 $) 3 * 4 * Copyright (C) 2001, 2002 Andy Grover <andrew.grover@intel.com> 5 * Copyright (C) 2001, 2002 Paul Diefenbaugh <paul.s.diefenbaugh@intel.com> 6 * 7 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 8 * 9 * This program is free software; you can redistribute it and/or modify 10 * it under the terms of the GNU General Public License as published by 11 * the Free Software Foundation; either version 2 of the License, or (at 12 * your option) any later version. 13 * 14 * This program is distributed in the hope that it will be useful, but 15 * WITHOUT ANY WARRANTY; without even the implied warranty of 16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 17 * General Public License for more details. 18 * 19 * You should have received a copy of the GNU General Public License along 20 * with this program; if not, write to the Free Software Foundation, Inc., 21 * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. 22 * 23 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 24 */ 25 26/* 27 * ACPI power-managed devices may be controlled in two ways: 28 * 1. via "Device Specific (D-State) Control" 29 * 2. via "Power Resource Control". 30 * This module is used to manage devices relying on Power Resource Control. 31 * 32 * An ACPI "power resource object" describes a software controllable power 33 * plane, clock plane, or other resource used by a power managed device. 34 * A device may rely on multiple power resources, and a power resource 35 * may be shared by multiple devices. 36 */ 37 38#include <linux/kernel.h> 39#include <linux/module.h> 40#include <linux/init.h> 41#include <linux/types.h> 42#include <linux/slab.h> 43#include <linux/pm_runtime.h> 44#include <linux/sysfs.h> 45#include <linux/acpi.h> 46#include "sleep.h" 47#include "internal.h" 48 49#define _COMPONENT ACPI_POWER_COMPONENT 50ACPI_MODULE_NAME("power"); 51#define ACPI_POWER_CLASS "power_resource" 52#define ACPI_POWER_DEVICE_NAME "Power Resource" 53#define ACPI_POWER_FILE_INFO "info" 54#define ACPI_POWER_FILE_STATUS "state" 55#define ACPI_POWER_RESOURCE_STATE_OFF 0x00 56#define ACPI_POWER_RESOURCE_STATE_ON 0x01 57#define ACPI_POWER_RESOURCE_STATE_UNKNOWN 0xFF 58 59struct acpi_power_resource { 60 struct acpi_device device; 61 struct list_head list_node; 62 char *name; 63 u32 system_level; 64 u32 order; 65 unsigned int ref_count; 66 bool wakeup_enabled; 67 struct mutex resource_lock; 68}; 69 70struct acpi_power_resource_entry { 71 struct list_head node; 72 struct acpi_power_resource *resource; 73}; 74 75static LIST_HEAD(acpi_power_resource_list); 76static DEFINE_MUTEX(power_resource_list_lock); 77 78/* -------------------------------------------------------------------------- 79 Power Resource Management 80 -------------------------------------------------------------------------- */ 81 82static inline 83struct acpi_power_resource *to_power_resource(struct acpi_device *device) 84{ 85 return container_of(device, struct acpi_power_resource, device); 86} 87 88static struct acpi_power_resource *acpi_power_get_context(acpi_handle handle) 89{ 90 struct acpi_device *device; 91 92 if (acpi_bus_get_device(handle, &device)) 93 return NULL; 94 95 return to_power_resource(device); 96} 97 98static int acpi_power_resources_list_add(acpi_handle handle, 99 struct list_head *list) 100{ 101 struct acpi_power_resource *resource = acpi_power_get_context(handle); 102 struct acpi_power_resource_entry *entry; 103 104 if (!resource || !list) 105 return -EINVAL; 106 107 entry = kzalloc(sizeof(*entry), GFP_KERNEL); 108 if (!entry) 109 return -ENOMEM; 110 111 entry->resource = resource; 112 if (!list_empty(list)) { 113 struct acpi_power_resource_entry *e; 114 115 list_for_each_entry(e, list, node) 116 if (e->resource->order > resource->order) { 117 list_add_tail(&entry->node, &e->node); 118 return 0; 119 } 120 } 121 list_add_tail(&entry->node, list); 122 return 0; 123} 124 125void acpi_power_resources_list_free(struct list_head *list) 126{ 127 struct acpi_power_resource_entry *entry, *e; 128 129 list_for_each_entry_safe(entry, e, list, node) { 130 list_del(&entry->node); 131 kfree(entry); 132 } 133} 134 135int acpi_extract_power_resources(union acpi_object *package, unsigned int start, 136 struct list_head *list) 137{ 138 unsigned int i; 139 int err = 0; 140 141 for (i = start; i < package->package.count; i++) { 142 union acpi_object *element = &package->package.elements[i]; 143 acpi_handle rhandle; 144 145 if (element->type != ACPI_TYPE_LOCAL_REFERENCE) { 146 err = -ENODATA; 147 break; 148 } 149 rhandle = element->reference.handle; 150 if (!rhandle) { 151 err = -ENODEV; 152 break; 153 } 154 err = acpi_add_power_resource(rhandle); 155 if (err) 156 break; 157 158 err = acpi_power_resources_list_add(rhandle, list); 159 if (err) 160 break; 161 } 162 if (err) 163 acpi_power_resources_list_free(list); 164 165 return err; 166} 167 168static int acpi_power_get_state(acpi_handle handle, int *state) 169{ 170 acpi_status status = AE_OK; 171 unsigned long long sta = 0; 172 char node_name[5]; 173 struct acpi_buffer buffer = { sizeof(node_name), node_name }; 174 175 176 if (!handle || !state) 177 return -EINVAL; 178 179 status = acpi_evaluate_integer(handle, "_STA", NULL, &sta); 180 if (ACPI_FAILURE(status)) 181 return -ENODEV; 182 183 *state = (sta & 0x01)?ACPI_POWER_RESOURCE_STATE_ON: 184 ACPI_POWER_RESOURCE_STATE_OFF; 185 186 acpi_get_name(handle, ACPI_SINGLE_NAME, &buffer); 187 188 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Resource [%s] is %s\n", 189 node_name, 190 *state ? "on" : "off")); 191 192 return 0; 193} 194 195static int acpi_power_get_list_state(struct list_head *list, int *state) 196{ 197 struct acpi_power_resource_entry *entry; 198 int cur_state; 199 200 if (!list || !state) 201 return -EINVAL; 202 203 /* The state of the list is 'on' IFF all resources are 'on'. */ 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 226static 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 240static 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 256static 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 266static 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 280static 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 303static 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 313static 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 332static 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 351static struct attribute *attrs[] = { 352 NULL, 353}; 354 355static 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 374static struct attribute_group wakeup_attr_group = { 375 .name = "power_resources_wakeup", 376 .attrs = attrs, 377}; 378 379static 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 398static 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 426static 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 437void 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 454int 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 */ 506int 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 */ 556int 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 */ 608int 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 658int 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 = ACPI_STATE_D3_COLD; 688 return 0; 689} 690 691int acpi_power_on_resources(struct acpi_device *device, int state) 692{ 693 if (!device || state < ACPI_STATE_D0 || state > ACPI_STATE_D3_HOT) 694 return -EINVAL; 695 696 return acpi_power_on_list(&device->power.states[state].resources); 697} 698 699int acpi_power_transition(struct acpi_device *device, int state) 700{ 701 int result = 0; 702 703 if (!device || (state < ACPI_STATE_D0) || (state > ACPI_STATE_D3_COLD)) 704 return -EINVAL; 705 706 if (device->power.state == state || !device->flags.power_manageable) 707 return 0; 708 709 if ((device->power.state < ACPI_STATE_D0) 710 || (device->power.state > ACPI_STATE_D3_COLD)) 711 return -ENODEV; 712 713 /* TBD: Resources must be ordered. */ 714 715 /* 716 * First we reference all power resources required in the target list 717 * (e.g. so the device doesn't lose power while transitioning). Then, 718 * we dereference all power resources used in the current list. 719 */ 720 if (state < ACPI_STATE_D3_COLD) 721 result = acpi_power_on_list( 722 &device->power.states[state].resources); 723 724 if (!result && device->power.state < ACPI_STATE_D3_COLD) 725 acpi_power_off_list( 726 &device->power.states[device->power.state].resources); 727 728 /* We shouldn't change the state unless the above operations succeed. */ 729 device->power.state = result ? ACPI_STATE_UNKNOWN : state; 730 731 return result; 732} 733 734static void acpi_release_power_resource(struct device *dev) 735{ 736 struct acpi_device *device = to_acpi_device(dev); 737 struct acpi_power_resource *resource; 738 739 resource = container_of(device, struct acpi_power_resource, device); 740 741 mutex_lock(&power_resource_list_lock); 742 list_del(&resource->list_node); 743 mutex_unlock(&power_resource_list_lock); 744 745 acpi_free_pnp_ids(&device->pnp); 746 kfree(resource); 747} 748 749static ssize_t acpi_power_in_use_show(struct device *dev, 750 struct device_attribute *attr, 751 char *buf) { 752 struct acpi_power_resource *resource; 753 754 resource = to_power_resource(to_acpi_device(dev)); 755 return sprintf(buf, "%u\n", !!resource->ref_count); 756} 757static DEVICE_ATTR(resource_in_use, 0444, acpi_power_in_use_show, NULL); 758 759static void acpi_power_sysfs_remove(struct acpi_device *device) 760{ 761 device_remove_file(&device->dev, &dev_attr_resource_in_use); 762} 763 764int acpi_add_power_resource(acpi_handle handle) 765{ 766 struct acpi_power_resource *resource; 767 struct acpi_device *device = NULL; 768 union acpi_object acpi_object; 769 struct acpi_buffer buffer = { sizeof(acpi_object), &acpi_object }; 770 acpi_status status; 771 int state, result = -ENODEV; 772 773 acpi_bus_get_device(handle, &device); 774 if (device) 775 return 0; 776 777 resource = kzalloc(sizeof(*resource), GFP_KERNEL); 778 if (!resource) 779 return -ENOMEM; 780 781 device = &resource->device; 782 acpi_init_device_object(device, handle, ACPI_BUS_TYPE_POWER, 783 ACPI_STA_DEFAULT); 784 mutex_init(&resource->resource_lock); 785 INIT_LIST_HEAD(&resource->list_node); 786 resource->name = device->pnp.bus_id; 787 strcpy(acpi_device_name(device), ACPI_POWER_DEVICE_NAME); 788 strcpy(acpi_device_class(device), ACPI_POWER_CLASS); 789 device->power.state = ACPI_STATE_UNKNOWN; 790 791 /* Evalute the object to get the system level and resource order. */ 792 status = acpi_evaluate_object(handle, NULL, NULL, &buffer); 793 if (ACPI_FAILURE(status)) 794 goto err; 795 796 resource->system_level = acpi_object.power_resource.system_level; 797 resource->order = acpi_object.power_resource.resource_order; 798 799 result = acpi_power_get_state(handle, &state); 800 if (result) 801 goto err; 802 803 printk(KERN_INFO PREFIX "%s [%s] (%s)\n", acpi_device_name(device), 804 acpi_device_bid(device), state ? "on" : "off"); 805 806 device->flags.match_driver = true; 807 result = acpi_device_add(device, acpi_release_power_resource); 808 if (result) 809 goto err; 810 811 if (!device_create_file(&device->dev, &dev_attr_resource_in_use)) 812 device->remove = acpi_power_sysfs_remove; 813 814 mutex_lock(&power_resource_list_lock); 815 list_add(&resource->list_node, &acpi_power_resource_list); 816 mutex_unlock(&power_resource_list_lock); 817 acpi_device_add_finalize(device); 818 return 0; 819 820 err: 821 acpi_release_power_resource(&device->dev); 822 return result; 823} 824 825#ifdef CONFIG_ACPI_SLEEP 826void acpi_resume_power_resources(void) 827{ 828 struct acpi_power_resource *resource; 829 830 mutex_lock(&power_resource_list_lock); 831 832 list_for_each_entry(resource, &acpi_power_resource_list, list_node) { 833 int result, state; 834 835 mutex_lock(&resource->resource_lock); 836 837 result = acpi_power_get_state(resource->device.handle, &state); 838 if (result) { 839 mutex_unlock(&resource->resource_lock); 840 continue; 841 } 842 843 if (state == ACPI_POWER_RESOURCE_STATE_OFF 844 && resource->ref_count) { 845 dev_info(&resource->device.dev, "Turning ON\n"); 846 __acpi_power_on(resource); 847 } else if (state == ACPI_POWER_RESOURCE_STATE_ON 848 && !resource->ref_count) { 849 dev_info(&resource->device.dev, "Turning OFF\n"); 850 __acpi_power_off(resource); 851 } 852 853 mutex_unlock(&resource->resource_lock); 854 } 855 856 mutex_unlock(&power_resource_list_lock); 857} 858#endif 859