ReactOS 0.4.15-dev-7712-gbbbcd8e
power.c File Reference
#include <precomp.h>
#include <debug.h>
Include dependency graph for power.c:

Go to the source code of this file.

Classes

struct  acpi_power_reference
 
struct  acpi_power_resource
 

Macros

#define NDEBUG
 
#define _COMPONENT   ACPI_POWER_COMPONENT
 
#define ACPI_POWER_RESOURCE_STATE_OFF   0x00
 
#define ACPI_POWER_RESOURCE_STATE_ON   0x01
 
#define ACPI_POWER_RESOURCE_STATE_UNKNOWN   0xFF
 

Functions

static int acpi_power_add (struct acpi_device *device)
 
static int acpi_power_remove (struct acpi_device *device, int type)
 
static int acpi_power_resume (struct acpi_device *device, int state)
 
static int acpi_power_get_context (ACPI_HANDLE handle, struct acpi_power_resource **resource)
 
static int acpi_power_get_state (ACPI_HANDLE handle, int *state)
 
static int acpi_power_get_list_state (struct acpi_handle_list *list, int *state)
 
static int acpi_power_on (ACPI_HANDLE handle, struct acpi_device *dev)
 
static int acpi_power_off_device (ACPI_HANDLE handle, struct acpi_device *dev)
 
int acpi_device_sleep_wake (struct acpi_device *dev, int enable, int sleep_state, int dev_state)
 
int acpi_enable_wakeup_device_power (struct acpi_device *dev, int sleep_state)
 
int acpi_disable_wakeup_device_power (struct acpi_device *dev)
 
int acpi_power_get_inferred_state (struct acpi_device *device)
 
int acpi_power_transition (struct acpi_device *device, int state)
 
int acpi_power_init (void)
 

Variables

int acpi_power_nocheck
 
static struct acpi_driver acpi_power_driver
 
static struct list_head acpi_power_resource_list
 

Macro Definition Documentation

◆ _COMPONENT

#define _COMPONENT   ACPI_POWER_COMPONENT

Definition at line 48 of file power.c.

◆ ACPI_POWER_RESOURCE_STATE_OFF

#define ACPI_POWER_RESOURCE_STATE_OFF   0x00

Definition at line 51 of file power.c.

◆ ACPI_POWER_RESOURCE_STATE_ON

#define ACPI_POWER_RESOURCE_STATE_ON   0x01

Definition at line 52 of file power.c.

◆ ACPI_POWER_RESOURCE_STATE_UNKNOWN

#define ACPI_POWER_RESOURCE_STATE_UNKNOWN   0xFF

Definition at line 53 of file power.c.

◆ NDEBUG

#define NDEBUG

Definition at line 45 of file power.c.

Function Documentation

◆ acpi_device_sleep_wake()

int acpi_device_sleep_wake ( struct acpi_device dev,
int  enable,
int  sleep_state,
int  dev_state 
)

acpi_device_sleep_wake - execute _DSW (Device Sleep Wake) or (deprecated in ACPI 3.0) _PSW (Power State Wake) @dev: Device to handle. @enable: 0 - disable, 1 - enable the wake capabilities of the device. @sleep_state: Target sleep state of the system. @dev_state: Target power state of the device.

Execute _DSW (Device Sleep Wake) or (deprecated in ACPI 3.0) _PSW (Power State Wake) for the device, if present. On failure reset the device's wakeup.flags.valid flag.

RETURN VALUE: 0 if either _DSW or _PSW has been successfully executed 0 if neither _DSW nor _PSW has been found -ENODEV if the execution of either _DSW or _PSW has failed

Definition at line 301 of file power.c.

303{
304 union acpi_object in_arg[3];
305 struct acpi_object_list arg_list = { 3, in_arg };
307
308 /*
309 * Try to execute _DSW first.
310 *
311 * Three arguments are needed for the _DSW object:
312 * Argument 0: enable/disable the wake capabilities
313 * Argument 1: target system state
314 * Argument 2: target device state
315 * When _DSW object is called to disable the wake capabilities, maybe
316 * the first argument is filled. The values of the other two arguments
317 * are meaningless.
318 */
319 in_arg[0].Type = ACPI_TYPE_INTEGER;
320 in_arg[0].Integer.Value = enable;
321 in_arg[1].Type = ACPI_TYPE_INTEGER;
322 in_arg[1].Integer.Value = sleep_state;
323 in_arg[2].Type = ACPI_TYPE_INTEGER;
324 in_arg[2].Integer.Value = dev_state;
325 status = AcpiEvaluateObject(dev->handle, "_DSW", &arg_list, NULL);
326 if (ACPI_SUCCESS(status)) {
327 return 0;
328 } else if (status != AE_NOT_FOUND) {
329 DPRINT1("_DSW execution failed\n");
330 dev->wakeup.flags.valid = 0;
331 return -1;
332 }
333
334 /* Execute _PSW */
335 arg_list.Count = 1;
336 in_arg[0].Integer.Value = enable;
337 status = AcpiEvaluateObject(dev->handle, "_PSW", &arg_list, NULL);
338 if (ACPI_FAILURE(status) && (status != AE_NOT_FOUND)) {
339 DPRINT1("_PSW execution failed\n");
340 dev->wakeup.flags.valid = 0;
341 return -1;
342 }
343
344 return 0;
345}
#define ACPI_FAILURE(a)
Definition: acexcep.h:95
#define AE_NOT_FOUND
Definition: acexcep.h:113
#define ACPI_SUCCESS(a)
Definition: acexcep.h:94
#define AE_OK
Definition: acexcep.h:97
#define ACPI_TYPE_INTEGER
Definition: actypes.h:688
UINT32 ACPI_STATUS
Definition: actypes.h:460
#define DPRINT1
Definition: precomp.h:8
#define NULL
Definition: types.h:112
@ arg_list
Definition: wpp_private.h:56
GLboolean enable
Definition: glext.h:11120
ACPI_STATUS AcpiEvaluateObject(ACPI_HANDLE Handle, ACPI_STRING Pathname, ACPI_OBJECT_LIST *ExternalParams, ACPI_BUFFER *ReturnBuffer)
Definition: nsxfeval.c:217
Definition: ps.c:97

Referenced by acpi_disable_wakeup_device_power(), and acpi_enable_wakeup_device_power().

◆ acpi_disable_wakeup_device_power()

int acpi_disable_wakeup_device_power ( struct acpi_device dev)

Definition at line 398 of file power.c.

399{
400 unsigned int i;
401 int err = 0;
402
403 if (!dev || !dev->wakeup.flags.valid)
404 return -1;
405
406 //mutex_lock(&acpi_device_lock);
407
408 if (--dev->wakeup.prepare_count > 0)
409 goto out;
410
411 /*
412 * Executing the code below even if prepare_count is already zero when
413 * the function is called may be useful, for example for initialisation.
414 */
415 if (dev->wakeup.prepare_count < 0)
416 dev->wakeup.prepare_count = 0;
417
418 err = acpi_device_sleep_wake(dev, 0, 0, 0);
419 if (err)
420 goto out;
421
422 /* Close power resource */
423 for (i = 0; i < dev->wakeup.resources.count; i++) {
425 dev->wakeup.resources.handles[i], dev);
426 if (ret) {
427 DPRINT("Transition power state\n");
428 dev->wakeup.flags.valid = 0;
429 err = -1;
430 goto out;
431 }
432 }
433
434 out:
435 //mutex_unlock(&acpi_device_lock);
436 return err;
437}
static int acpi_power_off_device(ACPI_HANDLE handle, struct acpi_device *dev)
Definition: power.c:237
int acpi_device_sleep_wake(struct acpi_device *dev, int enable, int sleep_state, int dev_state)
Definition: power.c:301
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
#define err(...)
static FILE * out
Definition: regtests2xml.c:44
#define DPRINT
Definition: sndvol32.h:71
int ret

◆ acpi_enable_wakeup_device_power()

int acpi_enable_wakeup_device_power ( struct acpi_device dev,
int  sleep_state 
)

Definition at line 353 of file power.c.

354{
355 unsigned int i;
356 int err = 0;
357
358 if (!dev || !dev->wakeup.flags.valid)
359 return -1;
360
361 //mutex_lock(&acpi_device_lock);
362
363 if (dev->wakeup.prepare_count++)
364 goto out;
365
366 /* Open power resource */
367 for (i = 0; i < dev->wakeup.resources.count; i++) {
368 int ret = acpi_power_on(dev->wakeup.resources.handles[i], dev);
369 if (ret) {
370 DPRINT( "Transition power state\n");
371 dev->wakeup.flags.valid = 0;
372 err = -1;
373 goto err_out;
374 }
375 }
376
377 /*
378 * Passing 3 as the third argument below means the device may be placed
379 * in arbitrary power state afterwards.
380 */
381 err = acpi_device_sleep_wake(dev, 1, sleep_state, 3);
382
383 err_out:
384 if (err)
385 dev->wakeup.prepare_count = 0;
386
387 out:
388 //mutex_unlock(&acpi_device_lock);
389 return err;
390}
static int acpi_power_on(ACPI_HANDLE handle, struct acpi_device *dev)
Definition: power.c:186

◆ acpi_power_add()

int acpi_power_add ( struct acpi_device device)
static

Definition at line 543 of file power.c.

545{
546 int result = 0, state;
551
552
553 if (!device)
554 return_VALUE(-1);
555
557 if (!resource)
558 return_VALUE(-4);
559
560 resource->device = device;
561 //mutex_init(&resource->resource_lock);
562 INIT_LIST_HEAD(&resource->reference);
563
564 strcpy(resource->name, device->pnp.bus_id);
567 device->driver_data = resource;
568
569 /* Evalute the object to get the system level and resource order. */
571 if (ACPI_FAILURE(status)) {
572 result = -15;
573 goto end;
574 }
575 resource->system_level = acpi_object.PowerResource.SystemLevel;
576 resource->order = acpi_object.PowerResource.ResourceOrder;
577
579 if (result)
580 goto end;
581
582 switch (state) {
584 device->power.state = ACPI_STATE_D0;
585 break;
587 device->power.state = ACPI_STATE_D3;
588 break;
589 default:
590 device->power.state = ACPI_STATE_UNKNOWN;
591 break;
592 }
593
594
595 DPRINT("%s [%s] (%s)\n", acpi_device_name(device),
596 acpi_device_bid(device), state?"on":"off");
597
598end:
599 if (result)
601
602 return result;
603}
char * strcpy(char *DstString, const char *SrcString)
Definition: utclib.c:388
#define return_VALUE(s)
Definition: acoutput.h:499
#define acpi_device_bid(d)
Definition: acpi_bus.h:186
#define acpi_device_class(d)
Definition: acpi_bus.h:191
#define acpi_device_name(d)
Definition: acpi_bus.h:190
#define ACPI_POWER_CLASS
Definition: acpi_drivers.h:197
#define ACPI_POWER_DEVICE_NAME
Definition: acpi_drivers.h:200
union acpi_object ACPI_OBJECT
#define ACPI_STATE_D0
Definition: actypes.h:633
#define ACPI_STATE_D3
Definition: actypes.h:636
#define ACPI_STATE_UNKNOWN
Definition: actypes.h:622
static int state
Definition: maze.c:121
#define ACPI_POWER_RESOURCE_STATE_OFF
Definition: power.c:51
#define ACPI_POWER_RESOURCE_STATE_ON
Definition: power.c:52
static int acpi_power_get_state(ACPI_HANDLE handle, int *state)
Definition: power.c:120
#define INIT_LIST_HEAD(ptr)
Definition: list.h:24
#define ExAllocatePoolWithTag(hernya, size, tag)
Definition: env_spec_w32.h:350
#define ExFreePool(addr)
Definition: env_spec_w32.h:352
#define NonPagedPool
Definition: env_spec_w32.h:307
GLuint GLuint end
Definition: gl.h:1545
GLuint buffer
Definition: glext.h:5915
GLuint64EXT * result
Definition: glext.h:11304
#define resource
Definition: kernel32.h:9
Definition: devices.h:37
struct acpi_object::@620 PowerResource

◆ acpi_power_get_context()

static int acpi_power_get_context ( ACPI_HANDLE  handle,
struct acpi_power_resource **  resource 
)
static

Definition at line 94 of file power.c.

97{
98 int result = 0;
99 struct acpi_device *device = NULL;
100
101 if (!resource)
102 return_VALUE(-15);
103
105 if (result) {
106 ACPI_DEBUG_PRINT((ACPI_DB_WARN, "Error getting context [%p]\n",
107 handle));
109 }
110
112 if (!*resource)
113 return_VALUE(-15);
114
115 return 0;
116}
#define ACPI_DEBUG_PRINT(pl)
Definition: acoutput.h:475
#define acpi_driver_data(d)
Definition: acpi_bus.h:289
int acpi_bus_get_device(ACPI_HANDLE handle, struct acpi_device **device)
Definition: bus.c:108

Referenced by acpi_power_off_device(), and acpi_power_on().

◆ acpi_power_get_inferred_state()

int acpi_power_get_inferred_state ( struct acpi_device device)

Definition at line 444 of file power.c.

446{
447 int result = 0;
448 struct acpi_handle_list *list = NULL;
449 int list_state = 0;
450 int i = 0;
451
452
453 if (!device)
454 return_VALUE(-1);
455
456 device->power.state = ACPI_STATE_UNKNOWN;
457
458 /*
459 * We know a device's inferred power state when all the resources
460 * required for a given D-state are 'on'.
461 */
462 for (i=ACPI_STATE_D0; i<ACPI_STATE_D3; i++) {
463 list = &device->power.states[i].resources;
464 if (list->count < 1)
465 continue;
466
467 result = acpi_power_get_list_state(list, &list_state);
468 if (result)
470
471 if (list_state == ACPI_POWER_RESOURCE_STATE_ON) {
472 device->power.state = i;
473 return_VALUE(0);
474 }
475 }
476
477 device->power.state = ACPI_STATE_D3;
478
479 return_VALUE(0);
480}
Definition: list.h:37
static int acpi_power_get_list_state(struct acpi_handle_list *list, int *state)
Definition: power.c:150

Referenced by acpi_bus_get_power().

◆ acpi_power_get_list_state()

static int acpi_power_get_list_state ( struct acpi_handle_list list,
int state 
)
static

Definition at line 150 of file power.c.

153{
154 int result = 0, state1;
155 UINT32 i = 0;
156
157 if (!list || !state)
158 return_VALUE(-1);
159
160 /* The state of the list is 'on' IFF all resources are 'on'. */
161
162 for (i=0; i<list->count; i++) {
163 /*
164 * The state of the power resource can be obtained by
165 * using the ACPI handle. In such case it is unnecessary to
166 * get the Power resource first and then get its state again.
167 */
168 result = acpi_power_get_state(list->handles[i], &state1);
169 if (result)
170 return result;
171
172 *state = state1;
173
175 break;
176 }
177
178 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Resource list is %s\n",
179 *state?"on":"off"));
180
181 return result;
182}
unsigned int UINT32
#define ACPI_DB_INFO
Definition: acoutput.h:153

Referenced by acpi_power_get_inferred_state().

◆ acpi_power_get_state()

static int acpi_power_get_state ( ACPI_HANDLE  handle,
int state 
)
static

Definition at line 120 of file power.c.

123{
125 unsigned long long sta = 0;
126 char node_name[5];
127 ACPI_BUFFER buffer = { sizeof(node_name), node_name };
128
129
130 if (!handle || !state)
131 return_VALUE(-1);
132
133 status = acpi_evaluate_integer(handle, "_STA", NULL, &sta);
134 if (ACPI_FAILURE(status))
135 return_VALUE(-15);
136
137 *state = (sta & 0x01)?ACPI_POWER_RESOURCE_STATE_ON:
139
141
142 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Resource [%s] is %s\n",
143 node_name, *state?"on":"off"));
144
145 return 0;
146}
#define ACPI_SINGLE_NAME
Definition: actypes.h:1063
ACPI_STATUS acpi_evaluate_integer(ACPI_HANDLE handle, ACPI_STRING pathname, ACPI_OBJECT_LIST *arguments, unsigned long long *data)
Definition: utils.c:242
ACPI_STATUS AcpiGetName(ACPI_HANDLE Handle, UINT32 NameType, ACPI_BUFFER *Buffer)
Definition: nsxfname.c:173

Referenced by acpi_power_add(), acpi_power_get_list_state(), and acpi_power_resume().

◆ acpi_power_init()

int acpi_power_init ( void  )

Definition at line 660 of file power.c.

661{
662 int result = 0;
663
664 DPRINT("acpi_power_init\n");
665
667
668
670 if (result < 0) {
671 return_VALUE(-15);
672 }
673
674 return_VALUE(0);
675}
int acpi_bus_register_driver(struct acpi_driver *driver)
Definition: bus.c:1029
static struct acpi_driver acpi_power_driver
Definition: power.c:61
static struct list_head acpi_power_resource_list
Definition: power.c:86

Referenced by acpi_init().

◆ acpi_power_off_device()

static int acpi_power_off_device ( ACPI_HANDLE  handle,
struct acpi_device dev 
)
static

Definition at line 237 of file power.c.

240{
241 int result = 0;
244 struct list_head *node, *next;
246
248 if (result)
249 return result;
250
251 //mutex_lock(&resource->resource_lock);
252 list_for_each_safe(node, next, &resource->reference) {
254 if (dev->handle == ref->device->handle) {
255 list_del(&ref->node);
257 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Device [%s] removed from resource [%s] references\n",
258 dev->pnp.bus_id, resource->name));
259 break;
260 }
261 }
262
263 if (!list_empty(&resource->reference)) {
264 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Cannot turn resource [%s] off - resource is in use\n",
265 resource->name));
266 //mutex_unlock(&resource->resource_lock);
267 return 0;
268 }
269 //mutex_unlock(&resource->resource_lock);
270
271 status = AcpiEvaluateObject(resource->device->handle, "_OFF", NULL, NULL);
272 if (ACPI_FAILURE(status))
273 return -1;
274
275 /* Update the power resource's _device_ power state */
276 resource->device->power.state = ACPI_STATE_D3;
277
278 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Resource [%s] turned off\n",
279 resource->name));
280
281 return 0;
282}
static int list_empty(struct list_entry *head)
Definition: list.h:58
static int acpi_power_get_context(ACPI_HANDLE handle, struct acpi_power_resource **resource)
Definition: power.c:94
#define list_for_each_safe(pos, n, head)
Definition: list.h:211
static void list_del(struct list_head *entry)
Definition: list.h:89
#define container_of(ptr, type, member)
Definition: glue.h:15
static unsigned __int64 next
Definition: rand_nt.c:6
Definition: list.h:15
Definition: send.c:48
Definition: dlist.c:348

Referenced by acpi_disable_wakeup_device_power(), and acpi_power_transition().

◆ acpi_power_on()

static int acpi_power_on ( ACPI_HANDLE  handle,
struct acpi_device dev 
)
static

Definition at line 186 of file power.c.

188{
189 int result = 0;
190 int found = 0;
193 struct list_head *node, *next;
195
197 if (result)
198 return result;
199
200 //mutex_lock(&resource->resource_lock);
201 list_for_each_safe(node, next, &resource->reference) {
203 if (dev->handle == ref->device->handle) {
204 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Device [%s] already referenced by resource [%s]\n",
205 dev->pnp.bus_id, resource->name));
206 found = 1;
207 break;
208 }
209 }
210
211 if (!found) {
213 if (!ref) {
214 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "kmalloc() failed\n"));
215 //mutex_unlock(&resource->resource_lock);
216 return -1;//-ENOMEM;
217 }
218 list_add_tail(&ref->node, &resource->reference);
219 ref->device = dev;
220 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Device [%s] added to resource [%s] references\n",
221 dev->pnp.bus_id, resource->name));
222 }
223 //mutex_unlock(&resource->resource_lock);
224
225 status = AcpiEvaluateObject(resource->device->handle, "_ON", NULL, NULL);
226 if (ACPI_FAILURE(status))
227 return_VALUE(-15);
228
229 /* Update the power resource's _device_ power state */
230 resource->device->power.state = ACPI_STATE_D0;
231
232 return 0;
233}
static void list_add_tail(struct list_entry *head, struct list_entry *entry)
Definition: list.h:83

Referenced by acpi_enable_wakeup_device_power(), acpi_power_resume(), and acpi_power_transition().

◆ acpi_power_remove()

int acpi_power_remove ( struct acpi_device device,
int  type 
)
static

Definition at line 607 of file power.c.

610{
612 struct list_head *node, *next;
613
615 return_VALUE(-1);
616
618
619 //mutex_lock(&resource->resource_lock);
620 list_for_each_safe(node, next, &resource->reference) {
622 list_del(&ref->node);
624 }
625 //mutex_unlock(&resource->resource_lock);
627
628 return_VALUE(0);
629}

◆ acpi_power_resume()

static int acpi_power_resume ( struct acpi_device device,
int  state 
)
static

Definition at line 631 of file power.c.

632{
633 int result = 0;
636
638 return -1;
639
641
643 if (result)
644 return result;
645
646 //mutex_lock(&resource->resource_lock);
648 !list_empty(&resource->reference)) {
649 ref = container_of(resource->reference.next, struct acpi_power_reference, node);
650 //mutex_unlock(&resource->resource_lock);
651 result = acpi_power_on(device->handle, ref->device);
652 return result;
653 }
654
655 //mutex_unlock(&resource->resource_lock);
656 return 0;
657}

◆ acpi_power_transition()

int acpi_power_transition ( struct acpi_device device,
int  state 
)

Definition at line 484 of file power.c.

487{
488 int result = 0;
489 struct acpi_handle_list *cl = NULL; /* Current Resources */
490 struct acpi_handle_list *tl = NULL; /* Target Resources */
491 unsigned int i = 0;
492
493 if (!device || (state < ACPI_STATE_D0) || (state > ACPI_STATE_D3))
494 return_VALUE(-1);
495
496 if ((device->power.state < ACPI_STATE_D0) || (device->power.state > ACPI_STATE_D3))
497 return_VALUE(-15);
498
499 cl = &device->power.states[device->power.state].resources;
500 tl = &device->power.states[state].resources;
501
502 /* TBD: Resources must be ordered. */
503
504 /*
505 * First we reference all power resources required in the target list
506 * (e.g. so the device doesn't lose power while transitioning).
507 */
508 for (i = 0; i < tl->count; i++) {
510 if (result)
511 goto end;
512 }
513
514 if (device->power.state == state) {
515 goto end;
516 }
517
518 /*
519 * Then we dereference all power resources used in the current list.
520 */
521 for (i = 0; i < cl->count; i++) {
523 if (result)
524 goto end;
525 }
526
527 end:
528 if (result)
529 device->power.state = ACPI_STATE_UNKNOWN;
530 else {
531 /* We shouldn't change the state till all above operations succeed */
532 device->power.state = state;
533 }
534
535 return result;
536}
UINT32 count
Definition: acpi_bus.h:37
ACPI_HANDLE handles[ACPI_MAX_HANDLES]
Definition: acpi_bus.h:38

Referenced by acpi_bus_set_power().

Variable Documentation

◆ acpi_power_driver

struct acpi_driver acpi_power_driver
static
Initial value:
= {
{0,0},
0,
0,
}
#define ACPI_POWER_DRIVER_NAME
Definition: acpi_drivers.h:199
#define ACPI_POWER_HID
Definition: acpi_drivers.h:198
static int acpi_power_add(struct acpi_device *device)
Definition: power.c:543
static int acpi_power_remove(struct acpi_device *device, int type)
Definition: power.c:607
static int acpi_power_resume(struct acpi_device *device, int state)
Definition: power.c:631

Definition at line 61 of file power.c.

Referenced by acpi_power_init().

◆ acpi_power_nocheck

int acpi_power_nocheck

Definition at line 55 of file power.c.

◆ acpi_power_resource_list

struct list_head acpi_power_resource_list
static

Definition at line 86 of file power.c.

Referenced by acpi_power_init().