reactos/drivers/bus/acpi/busmgr/power.c

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