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 <acpi/acpi_bus.h> 44 #include <acpi/acpi_drivers.h> 45 #include "sleep.h" 46 47 #define PREFIX "ACPI: " 48 49 #define _COMPONENT ACPI_POWER_COMPONENT 50 ACPI_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 59 int acpi_power_nocheck; 60 module_param_named(power_nocheck, acpi_power_nocheck, bool, 000); 61 62 static int acpi_power_add(struct acpi_device *device); 63 static int acpi_power_remove(struct acpi_device *device, int type); 64 static int acpi_power_resume(struct acpi_device *device); 65 66 static const struct acpi_device_id power_device_ids[] = { 67 {ACPI_POWER_HID, 0}, 68 {"", 0}, 69 }; 70 MODULE_DEVICE_TABLE(acpi, power_device_ids); 71 72 static struct acpi_driver acpi_power_driver = { 73 .name = "power", 74 .class = ACPI_POWER_CLASS, 75 .ids = power_device_ids, 76 .ops = { 77 .add = acpi_power_add, 78 .remove = acpi_power_remove, 79 .resume = acpi_power_resume, 80 }, 81 }; 82 83 struct acpi_power_resource { 84 struct acpi_device * device; 85 acpi_bus_id name; 86 u32 system_level; 87 u32 order; 88 unsigned int ref_count; 89 struct mutex resource_lock; 90 }; 91 92 static struct list_head acpi_power_resource_list; 93 94 /* -------------------------------------------------------------------------- 95 Power Resource Management 96 -------------------------------------------------------------------------- */ 97 98 static int 99 acpi_power_get_context(acpi_handle handle, 100 struct acpi_power_resource **resource) 101 { 102 int result = 0; 103 struct acpi_device *device = NULL; 104 105 106 if (!resource) 107 return -ENODEV; 108 109 result = acpi_bus_get_device(handle, &device); 110 if (result) { 111 printk(KERN_WARNING PREFIX "Getting context [%p]\n", handle); 112 return result; 113 } 114 115 *resource = acpi_driver_data(device); 116 if (!*resource) 117 return -ENODEV; 118 119 return 0; 120 } 121 122 static int acpi_power_get_state(acpi_handle handle, int *state) 123 { 124 acpi_status status = AE_OK; 125 unsigned long long sta = 0; 126 char node_name[5]; 127 struct acpi_buffer buffer = { sizeof(node_name), node_name }; 128 129 130 if (!handle || !state) 131 return -EINVAL; 132 133 status = acpi_evaluate_integer(handle, "_STA", NULL, &sta); 134 if (ACPI_FAILURE(status)) 135 return -ENODEV; 136 137 *state = (sta & 0x01)?ACPI_POWER_RESOURCE_STATE_ON: 138 ACPI_POWER_RESOURCE_STATE_OFF; 139 140 acpi_get_name(handle, ACPI_SINGLE_NAME, &buffer); 141 142 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Resource [%s] is %s\n", 143 node_name, 144 *state ? "on" : "off")); 145 146 return 0; 147 } 148 149 static int acpi_power_get_list_state(struct acpi_handle_list *list, int *state) 150 { 151 int result = 0, state1; 152 u32 i = 0; 153 154 155 if (!list || !state) 156 return -EINVAL; 157 158 /* The state of the list is 'on' IFF all resources are 'on'. */ 159 160 for (i = 0; i < list->count; i++) { 161 /* 162 * The state of the power resource can be obtained by 163 * using the ACPI handle. In such case it is unnecessary to 164 * get the Power resource first and then get its state again. 165 */ 166 result = acpi_power_get_state(list->handles[i], &state1); 167 if (result) 168 return result; 169 170 *state = state1; 171 172 if (*state != ACPI_POWER_RESOURCE_STATE_ON) 173 break; 174 } 175 176 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Resource list is %s\n", 177 *state ? "on" : "off")); 178 179 return result; 180 } 181 182 static int __acpi_power_on(struct acpi_power_resource *resource) 183 { 184 acpi_status status = AE_OK; 185 186 status = acpi_evaluate_object(resource->device->handle, "_ON", NULL, NULL); 187 if (ACPI_FAILURE(status)) 188 return -ENODEV; 189 190 /* Update the power resource's _device_ power state */ 191 resource->device->power.state = ACPI_STATE_D0; 192 193 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Power resource [%s] turned on\n", 194 resource->name)); 195 196 return 0; 197 } 198 199 static int acpi_power_on(acpi_handle handle) 200 { 201 int result = 0; 202 struct acpi_power_resource *resource = NULL; 203 204 result = acpi_power_get_context(handle, &resource); 205 if (result) 206 return result; 207 208 mutex_lock(&resource->resource_lock); 209 210 if (resource->ref_count++) { 211 ACPI_DEBUG_PRINT((ACPI_DB_INFO, 212 "Power resource [%s] already on", 213 resource->name)); 214 } else { 215 result = __acpi_power_on(resource); 216 if (result) 217 resource->ref_count--; 218 } 219 220 mutex_unlock(&resource->resource_lock); 221 222 return result; 223 } 224 225 static int acpi_power_off_device(acpi_handle handle) 226 { 227 int result = 0; 228 acpi_status status = AE_OK; 229 struct acpi_power_resource *resource = NULL; 230 231 result = acpi_power_get_context(handle, &resource); 232 if (result) 233 return result; 234 235 mutex_lock(&resource->resource_lock); 236 237 if (!resource->ref_count) { 238 ACPI_DEBUG_PRINT((ACPI_DB_INFO, 239 "Power resource [%s] already off", 240 resource->name)); 241 goto unlock; 242 } 243 244 if (--resource->ref_count) { 245 ACPI_DEBUG_PRINT((ACPI_DB_INFO, 246 "Power resource [%s] still in use\n", 247 resource->name)); 248 goto unlock; 249 } 250 251 status = acpi_evaluate_object(resource->device->handle, "_OFF", NULL, NULL); 252 if (ACPI_FAILURE(status)) { 253 result = -ENODEV; 254 } else { 255 /* Update the power resource's _device_ power state */ 256 resource->device->power.state = ACPI_STATE_D3; 257 258 ACPI_DEBUG_PRINT((ACPI_DB_INFO, 259 "Power resource [%s] turned off\n", 260 resource->name)); 261 } 262 263 unlock: 264 mutex_unlock(&resource->resource_lock); 265 266 return result; 267 } 268 269 /** 270 * acpi_device_sleep_wake - execute _DSW (Device Sleep Wake) or (deprecated in 271 * ACPI 3.0) _PSW (Power State Wake) 272 * @dev: Device to handle. 273 * @enable: 0 - disable, 1 - enable the wake capabilities of the device. 274 * @sleep_state: Target sleep state of the system. 275 * @dev_state: Target power state of the device. 276 * 277 * Execute _DSW (Device Sleep Wake) or (deprecated in ACPI 3.0) _PSW (Power 278 * State Wake) for the device, if present. On failure reset the device's 279 * wakeup.flags.valid flag. 280 * 281 * RETURN VALUE: 282 * 0 if either _DSW or _PSW has been successfully executed 283 * 0 if neither _DSW nor _PSW has been found 284 * -ENODEV if the execution of either _DSW or _PSW has failed 285 */ 286 int acpi_device_sleep_wake(struct acpi_device *dev, 287 int enable, int sleep_state, int dev_state) 288 { 289 union acpi_object in_arg[3]; 290 struct acpi_object_list arg_list = { 3, in_arg }; 291 acpi_status status = AE_OK; 292 293 /* 294 * Try to execute _DSW first. 295 * 296 * Three agruments are needed for the _DSW object: 297 * Argument 0: enable/disable the wake capabilities 298 * Argument 1: target system state 299 * Argument 2: target device state 300 * When _DSW object is called to disable the wake capabilities, maybe 301 * the first argument is filled. The values of the other two agruments 302 * are meaningless. 303 */ 304 in_arg[0].type = ACPI_TYPE_INTEGER; 305 in_arg[0].integer.value = enable; 306 in_arg[1].type = ACPI_TYPE_INTEGER; 307 in_arg[1].integer.value = sleep_state; 308 in_arg[2].type = ACPI_TYPE_INTEGER; 309 in_arg[2].integer.value = dev_state; 310 status = acpi_evaluate_object(dev->handle, "_DSW", &arg_list, NULL); 311 if (ACPI_SUCCESS(status)) { 312 return 0; 313 } else if (status != AE_NOT_FOUND) { 314 printk(KERN_ERR PREFIX "_DSW execution failed\n"); 315 dev->wakeup.flags.valid = 0; 316 return -ENODEV; 317 } 318 319 /* Execute _PSW */ 320 arg_list.count = 1; 321 in_arg[0].integer.value = enable; 322 status = acpi_evaluate_object(dev->handle, "_PSW", &arg_list, NULL); 323 if (ACPI_FAILURE(status) && (status != AE_NOT_FOUND)) { 324 printk(KERN_ERR PREFIX "_PSW execution failed\n"); 325 dev->wakeup.flags.valid = 0; 326 return -ENODEV; 327 } 328 329 return 0; 330 } 331 332 /* 333 * Prepare a wakeup device, two steps (Ref ACPI 2.0:P229): 334 * 1. Power on the power resources required for the wakeup device 335 * 2. Execute _DSW (Device Sleep Wake) or (deprecated in ACPI 3.0) _PSW (Power 336 * State Wake) for the device, if present 337 */ 338 int acpi_enable_wakeup_device_power(struct acpi_device *dev, int sleep_state) 339 { 340 int i, err = 0; 341 342 if (!dev || !dev->wakeup.flags.valid) 343 return -EINVAL; 344 345 mutex_lock(&acpi_device_lock); 346 347 if (dev->wakeup.prepare_count++) 348 goto out; 349 350 /* Open power resource */ 351 for (i = 0; i < dev->wakeup.resources.count; i++) { 352 int ret = acpi_power_on(dev->wakeup.resources.handles[i]); 353 if (ret) { 354 printk(KERN_ERR PREFIX "Transition power state\n"); 355 dev->wakeup.flags.valid = 0; 356 err = -ENODEV; 357 goto err_out; 358 } 359 } 360 361 /* 362 * Passing 3 as the third argument below means the device may be placed 363 * in arbitrary power state afterwards. 364 */ 365 err = acpi_device_sleep_wake(dev, 1, sleep_state, 3); 366 367 err_out: 368 if (err) 369 dev->wakeup.prepare_count = 0; 370 371 out: 372 mutex_unlock(&acpi_device_lock); 373 return err; 374 } 375 376 /* 377 * Shutdown a wakeup device, counterpart of above method 378 * 1. Execute _DSW (Device Sleep Wake) or (deprecated in ACPI 3.0) _PSW (Power 379 * State Wake) for the device, if present 380 * 2. Shutdown down the power resources 381 */ 382 int acpi_disable_wakeup_device_power(struct acpi_device *dev) 383 { 384 int i, err = 0; 385 386 if (!dev || !dev->wakeup.flags.valid) 387 return -EINVAL; 388 389 mutex_lock(&acpi_device_lock); 390 391 if (--dev->wakeup.prepare_count > 0) 392 goto out; 393 394 /* 395 * Executing the code below even if prepare_count is already zero when 396 * the function is called may be useful, for example for initialisation. 397 */ 398 if (dev->wakeup.prepare_count < 0) 399 dev->wakeup.prepare_count = 0; 400 401 err = acpi_device_sleep_wake(dev, 0, 0, 0); 402 if (err) 403 goto out; 404 405 /* Close power resource */ 406 for (i = 0; i < dev->wakeup.resources.count; i++) { 407 int ret = acpi_power_off_device( 408 dev->wakeup.resources.handles[i]); 409 if (ret) { 410 printk(KERN_ERR PREFIX "Transition power state\n"); 411 dev->wakeup.flags.valid = 0; 412 err = -ENODEV; 413 goto out; 414 } 415 } 416 417 out: 418 mutex_unlock(&acpi_device_lock); 419 return err; 420 } 421 422 /* -------------------------------------------------------------------------- 423 Device Power Management 424 -------------------------------------------------------------------------- */ 425 426 int acpi_power_get_inferred_state(struct acpi_device *device) 427 { 428 int result = 0; 429 struct acpi_handle_list *list = NULL; 430 int list_state = 0; 431 int i = 0; 432 433 434 if (!device) 435 return -EINVAL; 436 437 device->power.state = ACPI_STATE_UNKNOWN; 438 439 /* 440 * We know a device's inferred power state when all the resources 441 * required for a given D-state are 'on'. 442 */ 443 for (i = ACPI_STATE_D0; i < ACPI_STATE_D3; i++) { 444 list = &device->power.states[i].resources; 445 if (list->count < 1) 446 continue; 447 448 result = acpi_power_get_list_state(list, &list_state); 449 if (result) 450 return result; 451 452 if (list_state == ACPI_POWER_RESOURCE_STATE_ON) { 453 device->power.state = i; 454 return 0; 455 } 456 } 457 458 device->power.state = ACPI_STATE_D3; 459 460 return 0; 461 } 462 463 int acpi_power_transition(struct acpi_device *device, int state) 464 { 465 int result = 0; 466 struct acpi_handle_list *cl = NULL; /* Current Resources */ 467 struct acpi_handle_list *tl = NULL; /* Target Resources */ 468 int i = 0; 469 470 if (!device || (state < ACPI_STATE_D0) || (state > ACPI_STATE_D3)) 471 return -EINVAL; 472 473 if (device->power.state == state) 474 return 0; 475 476 if ((device->power.state < ACPI_STATE_D0) 477 || (device->power.state > ACPI_STATE_D3)) 478 return -ENODEV; 479 480 cl = &device->power.states[device->power.state].resources; 481 tl = &device->power.states[state].resources; 482 483 /* TBD: Resources must be ordered. */ 484 485 /* 486 * First we reference all power resources required in the target list 487 * (e.g. so the device doesn't lose power while transitioning). 488 */ 489 for (i = 0; i < tl->count; i++) { 490 result = acpi_power_on(tl->handles[i]); 491 if (result) 492 goto end; 493 } 494 495 /* 496 * Then we dereference all power resources used in the current list. 497 */ 498 for (i = 0; i < cl->count; i++) { 499 result = acpi_power_off_device(cl->handles[i]); 500 if (result) 501 goto end; 502 } 503 504 end: 505 if (result) 506 device->power.state = ACPI_STATE_UNKNOWN; 507 else { 508 /* We shouldn't change the state till all above operations succeed */ 509 device->power.state = state; 510 } 511 512 return result; 513 } 514 515 /* -------------------------------------------------------------------------- 516 Driver Interface 517 -------------------------------------------------------------------------- */ 518 519 static int acpi_power_add(struct acpi_device *device) 520 { 521 int result = 0, state; 522 acpi_status status = AE_OK; 523 struct acpi_power_resource *resource = NULL; 524 union acpi_object acpi_object; 525 struct acpi_buffer buffer = { sizeof(acpi_object), &acpi_object }; 526 527 528 if (!device) 529 return -EINVAL; 530 531 resource = kzalloc(sizeof(struct acpi_power_resource), GFP_KERNEL); 532 if (!resource) 533 return -ENOMEM; 534 535 resource->device = device; 536 mutex_init(&resource->resource_lock); 537 strcpy(resource->name, device->pnp.bus_id); 538 strcpy(acpi_device_name(device), ACPI_POWER_DEVICE_NAME); 539 strcpy(acpi_device_class(device), ACPI_POWER_CLASS); 540 device->driver_data = resource; 541 542 /* Evalute the object to get the system level and resource order. */ 543 status = acpi_evaluate_object(device->handle, NULL, NULL, &buffer); 544 if (ACPI_FAILURE(status)) { 545 result = -ENODEV; 546 goto end; 547 } 548 resource->system_level = acpi_object.power_resource.system_level; 549 resource->order = acpi_object.power_resource.resource_order; 550 551 result = acpi_power_get_state(device->handle, &state); 552 if (result) 553 goto end; 554 555 switch (state) { 556 case ACPI_POWER_RESOURCE_STATE_ON: 557 device->power.state = ACPI_STATE_D0; 558 break; 559 case ACPI_POWER_RESOURCE_STATE_OFF: 560 device->power.state = ACPI_STATE_D3; 561 break; 562 default: 563 device->power.state = ACPI_STATE_UNKNOWN; 564 break; 565 } 566 567 printk(KERN_INFO PREFIX "%s [%s] (%s)\n", acpi_device_name(device), 568 acpi_device_bid(device), state ? "on" : "off"); 569 570 end: 571 if (result) 572 kfree(resource); 573 574 return result; 575 } 576 577 static int acpi_power_remove(struct acpi_device *device, int type) 578 { 579 struct acpi_power_resource *resource; 580 581 if (!device) 582 return -EINVAL; 583 584 resource = acpi_driver_data(device); 585 if (!resource) 586 return -EINVAL; 587 588 kfree(resource); 589 590 return 0; 591 } 592 593 static int acpi_power_resume(struct acpi_device *device) 594 { 595 int result = 0, state; 596 struct acpi_power_resource *resource; 597 598 if (!device) 599 return -EINVAL; 600 601 resource = acpi_driver_data(device); 602 if (!resource) 603 return -EINVAL; 604 605 mutex_lock(&resource->resource_lock); 606 607 result = acpi_power_get_state(device->handle, &state); 608 if (result) 609 goto unlock; 610 611 if (state == ACPI_POWER_RESOURCE_STATE_OFF && resource->ref_count) 612 result = __acpi_power_on(resource); 613 614 unlock: 615 mutex_unlock(&resource->resource_lock); 616 617 return result; 618 } 619 620 int __init acpi_power_init(void) 621 { 622 INIT_LIST_HEAD(&acpi_power_resource_list); 623 return acpi_bus_register_driver(&acpi_power_driver); 624 } 625