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/proc_fs.h> 43 #include <linux/seq_file.h> 44 #include <acpi/acpi_bus.h> 45 #include <acpi/acpi_drivers.h> 46 47 #define _COMPONENT ACPI_POWER_COMPONENT 48 ACPI_MODULE_NAME("power"); 49 #define ACPI_POWER_COMPONENT 0x00800000 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 static int acpi_power_add(struct acpi_device *device); 58 static int acpi_power_remove(struct acpi_device *device, int type); 59 static int acpi_power_resume(struct acpi_device *device); 60 static int acpi_power_open_fs(struct inode *inode, struct file *file); 61 62 static struct acpi_device_id power_device_ids[] = { 63 {ACPI_POWER_HID, 0}, 64 {"", 0}, 65 }; 66 MODULE_DEVICE_TABLE(acpi, power_device_ids); 67 68 static struct acpi_driver acpi_power_driver = { 69 .name = "power", 70 .class = ACPI_POWER_CLASS, 71 .ids = power_device_ids, 72 .ops = { 73 .add = acpi_power_add, 74 .remove = acpi_power_remove, 75 .resume = acpi_power_resume, 76 }, 77 }; 78 79 struct acpi_power_reference { 80 struct list_head node; 81 struct acpi_device *device; 82 }; 83 84 struct acpi_power_resource { 85 struct acpi_device * device; 86 acpi_bus_id name; 87 u32 system_level; 88 u32 order; 89 int state; 90 struct mutex resource_lock; 91 struct list_head reference; 92 }; 93 94 static struct list_head acpi_power_resource_list; 95 96 static const struct file_operations acpi_power_fops = { 97 .open = acpi_power_open_fs, 98 .read = seq_read, 99 .llseek = seq_lseek, 100 .release = single_release, 101 }; 102 103 /* -------------------------------------------------------------------------- 104 Power Resource Management 105 -------------------------------------------------------------------------- */ 106 107 static int 108 acpi_power_get_context(acpi_handle handle, 109 struct acpi_power_resource **resource) 110 { 111 int result = 0; 112 struct acpi_device *device = NULL; 113 114 115 if (!resource) 116 return -ENODEV; 117 118 result = acpi_bus_get_device(handle, &device); 119 if (result) { 120 printk(KERN_WARNING PREFIX "Getting context [%p]\n", handle); 121 return result; 122 } 123 124 *resource = acpi_driver_data(device); 125 if (!resource) 126 return -ENODEV; 127 128 return 0; 129 } 130 131 static int acpi_power_get_state(struct acpi_power_resource *resource) 132 { 133 acpi_status status = AE_OK; 134 unsigned long sta = 0; 135 136 137 if (!resource) 138 return -EINVAL; 139 140 status = acpi_evaluate_integer(resource->device->handle, "_STA", NULL, &sta); 141 if (ACPI_FAILURE(status)) 142 return -ENODEV; 143 144 if (sta & 0x01) 145 resource->state = ACPI_POWER_RESOURCE_STATE_ON; 146 else 147 resource->state = ACPI_POWER_RESOURCE_STATE_OFF; 148 149 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Resource [%s] is %s\n", 150 resource->name, resource->state ? "on" : "off")); 151 152 return 0; 153 } 154 155 static int acpi_power_get_list_state(struct acpi_handle_list *list, int *state) 156 { 157 int result = 0; 158 struct acpi_power_resource *resource = NULL; 159 u32 i = 0; 160 161 162 if (!list || !state) 163 return -EINVAL; 164 165 /* The state of the list is 'on' IFF all resources are 'on'. */ 166 167 for (i = 0; i < list->count; i++) { 168 result = acpi_power_get_context(list->handles[i], &resource); 169 if (result) 170 return result; 171 result = acpi_power_get_state(resource); 172 if (result) 173 return result; 174 175 *state = resource->state; 176 177 if (*state != ACPI_POWER_RESOURCE_STATE_ON) 178 break; 179 } 180 181 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Resource list is %s\n", 182 *state ? "on" : "off")); 183 184 return result; 185 } 186 187 static int acpi_power_on(acpi_handle handle, struct acpi_device *dev) 188 { 189 int result = 0; 190 int found = 0; 191 acpi_status status = AE_OK; 192 struct acpi_power_resource *resource = NULL; 193 struct list_head *node, *next; 194 struct acpi_power_reference *ref; 195 196 197 result = acpi_power_get_context(handle, &resource); 198 if (result) 199 return result; 200 201 mutex_lock(&resource->resource_lock); 202 list_for_each_safe(node, next, &resource->reference) { 203 ref = container_of(node, struct acpi_power_reference, node); 204 if (dev->handle == ref->device->handle) { 205 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Device [%s] already referenced by resource [%s]\n", 206 dev->pnp.bus_id, resource->name)); 207 found = 1; 208 break; 209 } 210 } 211 212 if (!found) { 213 ref = kmalloc(sizeof (struct acpi_power_reference), 214 irqs_disabled() ? GFP_ATOMIC : GFP_KERNEL); 215 if (!ref) { 216 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "kmalloc() failed\n")); 217 mutex_unlock(&resource->resource_lock); 218 return -ENOMEM; 219 } 220 list_add_tail(&ref->node, &resource->reference); 221 ref->device = dev; 222 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Device [%s] added to resource [%s] references\n", 223 dev->pnp.bus_id, resource->name)); 224 } 225 mutex_unlock(&resource->resource_lock); 226 227 if (resource->state == ACPI_POWER_RESOURCE_STATE_ON) { 228 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Resource [%s] already on\n", 229 resource->name)); 230 return 0; 231 } 232 233 status = acpi_evaluate_object(resource->device->handle, "_ON", NULL, NULL); 234 if (ACPI_FAILURE(status)) 235 return -ENODEV; 236 237 result = acpi_power_get_state(resource); 238 if (result) 239 return result; 240 if (resource->state != ACPI_POWER_RESOURCE_STATE_ON) 241 return -ENOEXEC; 242 243 /* Update the power resource's _device_ power state */ 244 resource->device->power.state = ACPI_STATE_D0; 245 246 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Resource [%s] turned on\n", 247 resource->name)); 248 return 0; 249 } 250 251 static int acpi_power_off_device(acpi_handle handle, struct acpi_device *dev) 252 { 253 int result = 0; 254 acpi_status status = AE_OK; 255 struct acpi_power_resource *resource = NULL; 256 struct list_head *node, *next; 257 struct acpi_power_reference *ref; 258 259 260 result = acpi_power_get_context(handle, &resource); 261 if (result) 262 return result; 263 264 mutex_lock(&resource->resource_lock); 265 list_for_each_safe(node, next, &resource->reference) { 266 ref = container_of(node, struct acpi_power_reference, node); 267 if (dev->handle == ref->device->handle) { 268 list_del(&ref->node); 269 kfree(ref); 270 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Device [%s] removed from resource [%s] references\n", 271 dev->pnp.bus_id, resource->name)); 272 break; 273 } 274 } 275 276 if (!list_empty(&resource->reference)) { 277 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Cannot turn resource [%s] off - resource is in use\n", 278 resource->name)); 279 mutex_unlock(&resource->resource_lock); 280 return 0; 281 } 282 mutex_unlock(&resource->resource_lock); 283 284 if (resource->state == ACPI_POWER_RESOURCE_STATE_OFF) { 285 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Resource [%s] already off\n", 286 resource->name)); 287 return 0; 288 } 289 290 status = acpi_evaluate_object(resource->device->handle, "_OFF", NULL, NULL); 291 if (ACPI_FAILURE(status)) 292 return -ENODEV; 293 294 result = acpi_power_get_state(resource); 295 if (result) 296 return result; 297 if (resource->state != ACPI_POWER_RESOURCE_STATE_OFF) 298 return -ENOEXEC; 299 300 /* Update the power resource's _device_ power state */ 301 resource->device->power.state = ACPI_STATE_D3; 302 303 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Resource [%s] turned off\n", 304 resource->name)); 305 306 return 0; 307 } 308 309 /* 310 * Prepare a wakeup device, two steps (Ref ACPI 2.0:P229): 311 * 1. Power on the power resources required for the wakeup device 312 * 2. Enable _PSW (power state wake) for the device if present 313 */ 314 int acpi_enable_wakeup_device_power(struct acpi_device *dev) 315 { 316 union acpi_object arg = { ACPI_TYPE_INTEGER }; 317 struct acpi_object_list arg_list = { 1, &arg }; 318 acpi_status status = AE_OK; 319 int i; 320 int ret = 0; 321 322 if (!dev || !dev->wakeup.flags.valid) 323 return -1; 324 325 arg.integer.value = 1; 326 /* Open power resource */ 327 for (i = 0; i < dev->wakeup.resources.count; i++) { 328 ret = acpi_power_on(dev->wakeup.resources.handles[i], dev); 329 if (ret) { 330 printk(KERN_ERR PREFIX "Transition power state\n"); 331 dev->wakeup.flags.valid = 0; 332 return -1; 333 } 334 } 335 336 /* Execute PSW */ 337 status = acpi_evaluate_object(dev->handle, "_PSW", &arg_list, NULL); 338 if (ACPI_FAILURE(status) && (status != AE_NOT_FOUND)) { 339 printk(KERN_ERR PREFIX "Evaluate _PSW\n"); 340 dev->wakeup.flags.valid = 0; 341 ret = -1; 342 } 343 344 return ret; 345 } 346 347 /* 348 * Shutdown a wakeup device, counterpart of above method 349 * 1. Disable _PSW (power state wake) 350 * 2. Shutdown down the power resources 351 */ 352 int acpi_disable_wakeup_device_power(struct acpi_device *dev) 353 { 354 union acpi_object arg = { ACPI_TYPE_INTEGER }; 355 struct acpi_object_list arg_list = { 1, &arg }; 356 acpi_status status = AE_OK; 357 int i; 358 int ret = 0; 359 360 361 if (!dev || !dev->wakeup.flags.valid) 362 return -1; 363 364 arg.integer.value = 0; 365 /* Execute PSW */ 366 status = acpi_evaluate_object(dev->handle, "_PSW", &arg_list, NULL); 367 if (ACPI_FAILURE(status) && (status != AE_NOT_FOUND)) { 368 printk(KERN_ERR PREFIX "Evaluate _PSW\n"); 369 dev->wakeup.flags.valid = 0; 370 return -1; 371 } 372 373 /* Close power resource */ 374 for (i = 0; i < dev->wakeup.resources.count; i++) { 375 ret = acpi_power_off_device(dev->wakeup.resources.handles[i], dev); 376 if (ret) { 377 printk(KERN_ERR PREFIX "Transition power state\n"); 378 dev->wakeup.flags.valid = 0; 379 return -1; 380 } 381 } 382 383 return ret; 384 } 385 386 /* -------------------------------------------------------------------------- 387 Device Power Management 388 -------------------------------------------------------------------------- */ 389 390 int acpi_power_get_inferred_state(struct acpi_device *device) 391 { 392 int result = 0; 393 struct acpi_handle_list *list = NULL; 394 int list_state = 0; 395 int i = 0; 396 397 398 if (!device) 399 return -EINVAL; 400 401 device->power.state = ACPI_STATE_UNKNOWN; 402 403 /* 404 * We know a device's inferred power state when all the resources 405 * required for a given D-state are 'on'. 406 */ 407 for (i = ACPI_STATE_D0; i < ACPI_STATE_D3; i++) { 408 list = &device->power.states[i].resources; 409 if (list->count < 1) 410 continue; 411 412 result = acpi_power_get_list_state(list, &list_state); 413 if (result) 414 return result; 415 416 if (list_state == ACPI_POWER_RESOURCE_STATE_ON) { 417 device->power.state = i; 418 return 0; 419 } 420 } 421 422 device->power.state = ACPI_STATE_D3; 423 424 return 0; 425 } 426 427 int acpi_power_transition(struct acpi_device *device, int state) 428 { 429 int result = 0; 430 struct acpi_handle_list *cl = NULL; /* Current Resources */ 431 struct acpi_handle_list *tl = NULL; /* Target Resources */ 432 int i = 0; 433 434 435 if (!device || (state < ACPI_STATE_D0) || (state > ACPI_STATE_D3)) 436 return -EINVAL; 437 438 if ((device->power.state < ACPI_STATE_D0) 439 || (device->power.state > ACPI_STATE_D3)) 440 return -ENODEV; 441 442 cl = &device->power.states[device->power.state].resources; 443 tl = &device->power.states[state].resources; 444 445 if (!cl->count && !tl->count) { 446 result = -ENODEV; 447 goto end; 448 } 449 450 /* TBD: Resources must be ordered. */ 451 452 /* 453 * First we reference all power resources required in the target list 454 * (e.g. so the device doesn't lose power while transitioning). 455 */ 456 for (i = 0; i < tl->count; i++) { 457 result = acpi_power_on(tl->handles[i], device); 458 if (result) 459 goto end; 460 } 461 462 if (device->power.state == state) { 463 goto end; 464 } 465 466 /* 467 * Then we dereference all power resources used in the current list. 468 */ 469 for (i = 0; i < cl->count; i++) { 470 result = acpi_power_off_device(cl->handles[i], device); 471 if (result) 472 goto end; 473 } 474 475 end: 476 if (result) { 477 device->power.state = ACPI_STATE_UNKNOWN; 478 printk(KERN_WARNING PREFIX "Transitioning device [%s] to D%d\n", 479 device->pnp.bus_id, state); 480 } else { 481 /* We shouldn't change the state till all above operations succeed */ 482 device->power.state = state; 483 } 484 485 return result; 486 } 487 488 /* -------------------------------------------------------------------------- 489 FS Interface (/proc) 490 -------------------------------------------------------------------------- */ 491 492 static struct proc_dir_entry *acpi_power_dir; 493 494 static int acpi_power_seq_show(struct seq_file *seq, void *offset) 495 { 496 int count = 0; 497 int result = 0; 498 struct acpi_power_resource *resource = NULL; 499 struct list_head *node, *next; 500 struct acpi_power_reference *ref; 501 502 503 resource = seq->private; 504 505 if (!resource) 506 goto end; 507 508 result = acpi_power_get_state(resource); 509 if (result) 510 goto end; 511 512 seq_puts(seq, "state: "); 513 switch (resource->state) { 514 case ACPI_POWER_RESOURCE_STATE_ON: 515 seq_puts(seq, "on\n"); 516 break; 517 case ACPI_POWER_RESOURCE_STATE_OFF: 518 seq_puts(seq, "off\n"); 519 break; 520 default: 521 seq_puts(seq, "unknown\n"); 522 break; 523 } 524 525 mutex_lock(&resource->resource_lock); 526 list_for_each_safe(node, next, &resource->reference) { 527 ref = container_of(node, struct acpi_power_reference, node); 528 count++; 529 } 530 mutex_unlock(&resource->resource_lock); 531 532 seq_printf(seq, "system level: S%d\n" 533 "order: %d\n" 534 "reference count: %d\n", 535 resource->system_level, 536 resource->order, count); 537 538 end: 539 return 0; 540 } 541 542 static int acpi_power_open_fs(struct inode *inode, struct file *file) 543 { 544 return single_open(file, acpi_power_seq_show, PDE(inode)->data); 545 } 546 547 static int acpi_power_add_fs(struct acpi_device *device) 548 { 549 struct proc_dir_entry *entry = NULL; 550 551 552 if (!device) 553 return -EINVAL; 554 555 if (!acpi_device_dir(device)) { 556 acpi_device_dir(device) = proc_mkdir(acpi_device_bid(device), 557 acpi_power_dir); 558 if (!acpi_device_dir(device)) 559 return -ENODEV; 560 } 561 562 /* 'status' [R] */ 563 entry = create_proc_entry(ACPI_POWER_FILE_STATUS, 564 S_IRUGO, acpi_device_dir(device)); 565 if (!entry) 566 return -EIO; 567 else { 568 entry->proc_fops = &acpi_power_fops; 569 entry->data = acpi_driver_data(device); 570 } 571 572 return 0; 573 } 574 575 static int acpi_power_remove_fs(struct acpi_device *device) 576 { 577 578 if (acpi_device_dir(device)) { 579 remove_proc_entry(ACPI_POWER_FILE_STATUS, 580 acpi_device_dir(device)); 581 remove_proc_entry(acpi_device_bid(device), acpi_power_dir); 582 acpi_device_dir(device) = NULL; 583 } 584 585 return 0; 586 } 587 588 /* -------------------------------------------------------------------------- 589 Driver Interface 590 -------------------------------------------------------------------------- */ 591 592 static int acpi_power_add(struct acpi_device *device) 593 { 594 int result = 0; 595 acpi_status status = AE_OK; 596 struct acpi_power_resource *resource = NULL; 597 union acpi_object acpi_object; 598 struct acpi_buffer buffer = { sizeof(acpi_object), &acpi_object }; 599 600 601 if (!device) 602 return -EINVAL; 603 604 resource = kzalloc(sizeof(struct acpi_power_resource), GFP_KERNEL); 605 if (!resource) 606 return -ENOMEM; 607 608 resource->device = device; 609 mutex_init(&resource->resource_lock); 610 INIT_LIST_HEAD(&resource->reference); 611 strcpy(resource->name, device->pnp.bus_id); 612 strcpy(acpi_device_name(device), ACPI_POWER_DEVICE_NAME); 613 strcpy(acpi_device_class(device), ACPI_POWER_CLASS); 614 acpi_driver_data(device) = resource; 615 616 /* Evalute the object to get the system level and resource order. */ 617 status = acpi_evaluate_object(device->handle, NULL, NULL, &buffer); 618 if (ACPI_FAILURE(status)) { 619 result = -ENODEV; 620 goto end; 621 } 622 resource->system_level = acpi_object.power_resource.system_level; 623 resource->order = acpi_object.power_resource.resource_order; 624 625 result = acpi_power_get_state(resource); 626 if (result) 627 goto end; 628 629 switch (resource->state) { 630 case ACPI_POWER_RESOURCE_STATE_ON: 631 device->power.state = ACPI_STATE_D0; 632 break; 633 case ACPI_POWER_RESOURCE_STATE_OFF: 634 device->power.state = ACPI_STATE_D3; 635 break; 636 default: 637 device->power.state = ACPI_STATE_UNKNOWN; 638 break; 639 } 640 641 result = acpi_power_add_fs(device); 642 if (result) 643 goto end; 644 645 printk(KERN_INFO PREFIX "%s [%s] (%s)\n", acpi_device_name(device), 646 acpi_device_bid(device), resource->state ? "on" : "off"); 647 648 end: 649 if (result) 650 kfree(resource); 651 652 return result; 653 } 654 655 static int acpi_power_remove(struct acpi_device *device, int type) 656 { 657 struct acpi_power_resource *resource = NULL; 658 struct list_head *node, *next; 659 660 661 if (!device || !acpi_driver_data(device)) 662 return -EINVAL; 663 664 resource = acpi_driver_data(device); 665 666 acpi_power_remove_fs(device); 667 668 mutex_lock(&resource->resource_lock); 669 list_for_each_safe(node, next, &resource->reference) { 670 struct acpi_power_reference *ref = container_of(node, struct acpi_power_reference, node); 671 list_del(&ref->node); 672 kfree(ref); 673 } 674 mutex_unlock(&resource->resource_lock); 675 676 kfree(resource); 677 678 return 0; 679 } 680 681 static int acpi_power_resume(struct acpi_device *device) 682 { 683 int result = 0; 684 struct acpi_power_resource *resource = NULL; 685 struct acpi_power_reference *ref; 686 687 if (!device || !acpi_driver_data(device)) 688 return -EINVAL; 689 690 resource = (struct acpi_power_resource *)acpi_driver_data(device); 691 692 result = acpi_power_get_state(resource); 693 if (result) 694 return result; 695 696 mutex_lock(&resource->resource_lock); 697 if ((resource->state == ACPI_POWER_RESOURCE_STATE_OFF) && 698 !list_empty(&resource->reference)) { 699 ref = container_of(resource->reference.next, struct acpi_power_reference, node); 700 mutex_unlock(&resource->resource_lock); 701 result = acpi_power_on(device->handle, ref->device); 702 return result; 703 } 704 705 mutex_unlock(&resource->resource_lock); 706 return 0; 707 } 708 709 static int __init acpi_power_init(void) 710 { 711 int result = 0; 712 713 714 if (acpi_disabled) 715 return 0; 716 717 INIT_LIST_HEAD(&acpi_power_resource_list); 718 719 acpi_power_dir = proc_mkdir(ACPI_POWER_CLASS, acpi_root_dir); 720 if (!acpi_power_dir) 721 return -ENODEV; 722 723 result = acpi_bus_register_driver(&acpi_power_driver); 724 if (result < 0) { 725 remove_proc_entry(ACPI_POWER_CLASS, acpi_root_dir); 726 return -ENODEV; 727 } 728 729 return 0; 730 } 731 732 subsys_initcall(acpi_power_init); 733