projects / reactos.git / blob
? search:


6b04ea7c5f0d5b64127b56179e96f2effd51138f
[reactos.git] / reactos / drivers / bus / acpi / ospm / busmgr / bmpower.c
1 /****************************************************************************
2 *
3 * Module Name: bmpower.c - Driver for ACPI Power Resource 'devices'
4 * $Revision: 1.1 $
5 *
6 ****************************************************************************/
7
8 /*
9 * Copyright (C) 2000, 2001 Andrew Grover
10 *
11 * This program is free software; you can redistribute it and/or modify
12 * it under the terms of the GNU General Public License as published by
13 * the Free Software Foundation; either version 2 of the License, or
14 * (at your option) any later version.
15 *
16 * This program is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 * GNU General Public License for more details.
20 *
21 * You should have received a copy of the GNU General Public License
22 * along with this program; if not, write to the Free Software
23 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
24 */
25
26 /*
27 * TODO:
28 * -----
29 * 1. Sequencing of power resource list transitions.
30 * 2. Global serialization of power resource transtions (see ACPI
31 * spec section 7.1.2/7.1.3).
32 * 3. Better error handling.
33 */
34
35
36 #include <acpi.h>
37 #include "bm.h"
38 #include "bmpower.h"
39
40
41 #define _COMPONENT ACPI_POWER_CONTROL
42 MODULE_NAME ("bmpower")
43
44
45 /****************************************************************************
46 * Function Prototypes
47 ****************************************************************************/
48
49 ACPI_STATUS
50 bm_pr_notify (
51 BM_NOTIFY notify_type,
52 BM_HANDLE device_handle,
53 void **context);
54
55 ACPI_STATUS
56 bm_pr_request (
57 BM_REQUEST *request,
58 void *context);
59
60
61 /****************************************************************************
62 * Internal Functions
63 ****************************************************************************/
64
65 /****************************************************************************
66 *
67 * FUNCTION: bm_pr_print
68 *
69 * PARAMETERS: <TBD>
70 *
71 * RETURN: <TBD>
72 *
73 * DESCRIPTION: <TBD>
74 *
75 ****************************************************************************/
76
77 ACPI_STATUS
78 bm_pr_print (
79 BM_POWER_RESOURCE *pr)
80 {
81 ACPI_BUFFER buffer;
82
83 if (!pr) {
84 return(AE_BAD_PARAMETER);
85 }
86
87 buffer.length = 256;
88 buffer.pointer = acpi_os_callocate(buffer.length);
89 if (!buffer.pointer) {
90 return(AE_NO_MEMORY);
91 }
92
93 acpi_get_name(pr->acpi_handle, ACPI_FULL_PATHNAME, &buffer);
94
95 acpi_os_printf("Power Resource: found\n");
96
97 DEBUG_PRINT(ACPI_INFO, ("+------------------------------------------------------------\n"));
98 DEBUG_PRINT(ACPI_INFO, ("PowerResource[0x%02X]|[0x%08X] %s\n", pr->device_handle, pr->acpi_handle, buffer.pointer));
99 DEBUG_PRINT(ACPI_INFO, (" system_level[S%d] resource_order[%d]\n", pr->system_level, pr->resource_order));
100 DEBUG_PRINT(ACPI_INFO, (" state[D%d] reference_count[%d]\n", pr->state, pr->reference_count));
101 DEBUG_PRINT(ACPI_INFO, ("+------------------------------------------------------------\n"));
102
103 acpi_os_free(buffer.pointer);
104
105 return(AE_OK);
106 }
107
108
109 /****************************************************************************
110 *
111 * FUNCTION: bm_pr_get_state
112 *
113 * PARAMETERS: <TBD>
114 *
115 * RETURN: <TBD>
116 *
117 * DESCRIPTION: <TBD>
118 *
119 ****************************************************************************/
120
121 ACPI_STATUS
122 bm_pr_get_state (
123 BM_POWER_RESOURCE *pr)
124 {
125 ACPI_STATUS status = AE_OK;
126 BM_DEVICE_STATUS device_status = BM_STATUS_UNKNOWN;
127
128 FUNCTION_TRACE("bm_pr_get_state");
129
130 if (!pr) {
131 return_ACPI_STATUS(AE_BAD_PARAMETER);
132 }
133
134 pr->state = ACPI_STATE_UNKNOWN;
135
136 /*
137 * Evaluate _STA:
138 * --------------
139 * Evalute _STA to determine whether the power resource is ON or OFF.
140 * Note that if the power resource isn't present we'll get AE_OK but
141 * an unknown status.
142 */
143 status = bm_get_device_status(pr->device_handle, &device_status);
144 if (ACPI_FAILURE(status)) {
145 DEBUG_PRINT(ACPI_ERROR, ("Error reading status for power resource [0x%02x].\n", pr->device_handle));
146 return_ACPI_STATUS(status);
147 }
148 if (device_status == BM_STATUS_UNKNOWN) {
149 DEBUG_PRINT(ACPI_ERROR, ("Error reading status for power resource [0x%02x].\n", pr->device_handle));
150 return_ACPI_STATUS(AE_NOT_EXIST);
151 }
152
153 /*
154 * Mask off all bits but the first as some systems return non-standard
155 * values (e.g. 0x51).
156 */
157 switch (device_status & 0x01) {
158 case 0:
159 DEBUG_PRINT(ACPI_INFO, ("Power resource [0x%02x] is OFF.\n", pr->device_handle));
160 pr->state = ACPI_STATE_D3;
161 break;
162 case 1:
163 DEBUG_PRINT(ACPI_INFO, ("Power resource [0x%02x] is ON.\n", pr->device_handle));
164 pr->state = ACPI_STATE_D0;
165 break;
166 }
167
168 return_ACPI_STATUS(status);
169 }
170
171
172 /****************************************************************************
173 *
174 * FUNCTION: bm_pr_set_state
175 *
176 * PARAMETERS: <TBD>
177 *
178 * RETURN: <TBD>
179 *
180 * DESCRIPTION: <TBD>
181 *
182 ****************************************************************************/
183
184 ACPI_STATUS
185 bm_pr_set_state (
186 BM_POWER_RESOURCE *pr,
187 BM_POWER_STATE target_state)
188 {
189 ACPI_STATUS status = AE_OK;
190
191 FUNCTION_TRACE("bm_pr_set_state");
192
193 if (!pr) {
194 return_ACPI_STATUS(AE_BAD_PARAMETER);
195 }
196
197 status = bm_pr_get_state(pr);
198 if (ACPI_FAILURE(status)) {
199 return_ACPI_STATUS(status);
200 }
201
202 if (target_state == pr->state) {
203 DEBUG_PRINT(ACPI_INFO, ("Power resource [0x%02X] already at target power state [D%d].\n", pr->device_handle, pr->state));
204 return_ACPI_STATUS(AE_OK);
205 }
206
207 switch (target_state) {
208
209 case ACPI_STATE_D0:
210 DEBUG_PRINT(ACPI_INFO, ("Turning power resource [0x%02X] ON.\n", pr->device_handle));
211 status = bm_evaluate_object(pr->acpi_handle, "_ON", NULL, NULL);
212 break;
213
214 case ACPI_STATE_D3:
215 DEBUG_PRINT(ACPI_INFO, ("Turning power resource [0x%02X] OFF.\n", pr->device_handle));
216 status = bm_evaluate_object(pr->acpi_handle, "_OFF", NULL, NULL);
217 break;
218
219 default:
220 status = AE_BAD_PARAMETER;
221 break;
222 }
223
224 status = bm_pr_get_state(pr);
225 if (ACPI_FAILURE(status)) {
226 return_ACPI_STATUS(status);
227 }
228
229 return_ACPI_STATUS(status);
230 }
231
232
233 /****************************************************************************
234 *
235 * FUNCTION: bm_pr_list_get_state
236 *
237 * PARAMETERS: <TBD>
238 *
239 * RETURN: <TBD>
240 *
241 * DESCRIPTION: <TBD>
242 *
243 ****************************************************************************/
244
245 ACPI_STATUS
246 bm_pr_list_get_state (
247 BM_HANDLE_LIST *pr_list,
248 BM_POWER_STATE *power_state)
249 {
250 ACPI_STATUS status = AE_OK;
251 BM_POWER_RESOURCE *pr = NULL;
252 u32 i = 0;
253
254 FUNCTION_TRACE("bm_pr_list_get_state");
255
256 if (!pr_list || !power_state) {
257 return_ACPI_STATUS(AE_BAD_PARAMETER);
258 }
259
260 if (pr_list->count < 1) {
261 pr->state = ACPI_STATE_UNKNOWN;
262 return_ACPI_STATUS(AE_ERROR);
263 }
264
265 (*power_state) = ACPI_STATE_D0;
266
267 /*
268 * Calculate Current power_state:
269 * -----------------------------
270 * The current state of a list of power resources is ON if all
271 * power resources are currently in the ON state. In other words,
272 * if any power resource in the list is OFF then the collection
273 * isn't fully ON.
274 */
275 for (i = 0; i < pr_list->count; i++) {
276
277 status = bm_get_device_context(pr_list->handles[i],
278 (BM_DRIVER_CONTEXT*)(&pr));
279 if (ACPI_FAILURE(status)) {
280 DEBUG_PRINT(ACPI_WARN, ("Invalid reference to power resource [0x%02X].\n", pr_list->handles[i]));
281 (*power_state) = ACPI_STATE_UNKNOWN;
282 break;
283 }
284
285 status = bm_pr_get_state(pr);
286 if (ACPI_FAILURE(status)) {
287 (*power_state) = ACPI_STATE_UNKNOWN;
288 break;
289 }
290
291 if (pr->state != ACPI_STATE_D0) {
292 (*power_state) = pr->state;
293 break;
294 }
295 }
296
297 return_ACPI_STATUS(status);
298 }
299
300
301 /****************************************************************************
302 *
303 * FUNCTION: bm_pr_list_transition
304 *
305 * PARAMETERS: <TBD>
306 *
307 * RETURN: <TBD>
308 *
309 * DESCRIPTION: <TBD>
310 *
311 ****************************************************************************/
312
313 ACPI_STATUS
314 bm_pr_list_transition (
315 BM_HANDLE_LIST *current_list,
316 BM_HANDLE_LIST *target_list)
317 {
318 ACPI_STATUS status = AE_OK;
319 BM_POWER_RESOURCE *pr = NULL;
320 u32 i = 0;
321
322 FUNCTION_TRACE("bm_pr_list_transition");
323
324 if (!current_list || !target_list) {
325 return_ACPI_STATUS(AE_BAD_PARAMETER);
326 }
327
328 /*
329 * Reference Target:
330 * -----------------
331 * Reference all resources for the target power state first (so
332 * the device doesn't get turned off while transitioning). Power
333 * resources that aren't on (new reference count of 1) are turned on.
334 */
335 for (i = 0; i < target_list->count; i++) {
336
337 status = bm_get_device_context(target_list->handles[i],
338 (BM_DRIVER_CONTEXT*)(&pr));
339 if (ACPI_FAILURE(status)) {
340 DEBUG_PRINT(ACPI_WARN, ("Invalid reference to power resource [0x%02X].\n", target_list->handles[i]));
341 continue;
342 }
343
344 if (++pr->reference_count == 1) {
345 /* TODO: Need ordering based upon resource_order */
346 status = bm_pr_set_state(pr, ACPI_STATE_D0);
347 if (ACPI_FAILURE(status)) {
348 /* TODO: How do we handle this? */
349 DEBUG_PRINT(ACPI_WARN, ("Unable to change power state for power resource [0x%02X].\n", target_list->handles[i]));
350 }
351 }
352 }
353
354 /*
355 * Dereference Current:
356 * --------------------
357 * Dereference all resources for the current power state. Power
358 * resources no longer referenced (new reference count of 0) are
359 * turned off.
360 */
361 for (i = 0; i < current_list->count; i++) {
362
363 status = bm_get_device_context(current_list->handles[i],
364 (BM_DRIVER_CONTEXT*)(&pr));
365 if (ACPI_FAILURE(status)) {
366 DEBUG_PRINT(ACPI_WARN, ("Invalid reference to power resource [0x%02X].\n", target_list->handles[i]));
367 continue;
368 }
369
370 if (--pr->reference_count == 0) {
371 /* TODO: Need ordering based upon resource_order */
372 status = bm_pr_set_state(pr, ACPI_STATE_D3);
373 if (ACPI_FAILURE(status)) {
374 /* TODO: How do we handle this? */
375 DEBUG_PRINT(ACPI_ERROR, ("Unable to change power state for power resource [0x%02X].\n", current_list->handles[i]));
376 }
377 }
378 }
379
380 return_ACPI_STATUS(status);
381 }
382
383
384 /****************************************************************************
385 *
386 * FUNCTION: bm_pr_add_device
387 *
388 * PARAMETERS: <TBD>
389 *
390 * RETURN: <TBD>
391 *
392 * DESCRIPTION: <TBD>
393 *
394 ****************************************************************************/
395
396 ACPI_STATUS
397 bm_pr_add_device (
398 BM_HANDLE device_handle,
399 void **context)
400 {
401 ACPI_STATUS status = AE_OK;
402 BM_POWER_RESOURCE *pr = NULL;
403 BM_DEVICE *device = NULL;
404 ACPI_BUFFER buffer;
405 ACPI_OBJECT acpi_object;
406
407 FUNCTION_TRACE("bm_pr_add_device");
408
409 DEBUG_PRINT(ACPI_INFO, ("Adding power resource [0x%02X].\n", device_handle));
410
411 if (!context || *context) {
412 return_ACPI_STATUS(AE_BAD_PARAMETER);
413 }
414
415 buffer.length = sizeof(ACPI_OBJECT);
416 buffer.pointer = &acpi_object;
417
418 /*
419 * Get information on this device.
420 */
421 status = bm_get_device_info(device_handle, &device);
422 if (ACPI_FAILURE(status)) {
423 return_ACPI_STATUS(status);
424 }
425
426 /*
427 * Allocate a new BM_POWER_RESOURCE structure.
428 */
429 pr = acpi_os_callocate(sizeof(BM_POWER_RESOURCE));
430 if (!pr) {
431 return_ACPI_STATUS(AE_NO_MEMORY);
432 }
433
434 pr->device_handle = device->handle;
435 pr->acpi_handle = device->acpi_handle;
436
437 /*
438 * Get information on this power resource.
439 */
440 status = acpi_evaluate_object(pr->acpi_handle, NULL, NULL, &buffer);
441 if (ACPI_FAILURE(status)) {
442 goto end;
443 }
444
445 pr->system_level = acpi_object.power_resource.system_level;
446 pr->resource_order = acpi_object.power_resource.resource_order;
447 pr->state = ACPI_STATE_UNKNOWN;
448 pr->reference_count = 0;
449
450 /*
451 * Get the power resource's current state (ON|OFF).
452 */
453 status = bm_pr_get_state(pr);
454
455 end:
456 if (ACPI_FAILURE(status)) {
457 acpi_os_free(pr);
458 }
459 else {
460 *context = pr;
461 bm_pr_print(pr);
462 }
463
464 return_ACPI_STATUS(status);
465 }
466
467
468 /****************************************************************************
469 *
470 * FUNCTION: bm_pr_remove_device
471 *
472 * PARAMETERS: <TBD>
473 *
474 * RETURN: <TBD>
475 *
476 * DESCRIPTION: <TBD>
477 *
478 ****************************************************************************/
479
480 ACPI_STATUS
481 bm_pr_remove_device (
482 void **context)
483 {
484 ACPI_STATUS status = AE_OK;
485 BM_POWER_RESOURCE *pr = NULL;
486
487 FUNCTION_TRACE("bm_pr_remove_device");
488
489 if (!context || !*context) {
490 return_ACPI_STATUS(AE_BAD_PARAMETER);
491 }
492
493 pr = (BM_POWER_RESOURCE*)*context;
494
495 DEBUG_PRINT(ACPI_INFO, ("Removing power resource [0x%02X].\n", pr->device_handle));
496
497 acpi_os_free(pr);
498
499 return_ACPI_STATUS(status);
500 }
501
502
503 /****************************************************************************
504 * External Functions
505 ****************************************************************************/
506
507 /****************************************************************************
508 *
509 * FUNCTION: bm_pr_initialize
510 *
511 * PARAMETERS: <none>
512 *
513 * RETURN:
514 *
515 * DESCRIPTION: <TBD>
516 *
517 ****************************************************************************/
518
519 ACPI_STATUS
520 bm_pr_initialize (void)
521 {
522 ACPI_STATUS status = AE_OK;
523 BM_DEVICE_ID criteria;
524 BM_DRIVER driver;
525
526 FUNCTION_TRACE("bm_pr_initialize");
527
528 MEMSET(&criteria, 0, sizeof(BM_DEVICE_ID));
529 MEMSET(&driver, 0, sizeof(BM_DRIVER));
530
531 criteria.type = BM_TYPE_POWER_RESOURCE;
532
533 driver.notify = &bm_pr_notify;
534 driver.request = &bm_pr_request;
535
536 status = bm_register_driver(&criteria, &driver);
537
538 return_ACPI_STATUS(status);
539 }
540
541
542 /****************************************************************************
543 *
544 * FUNCTION: bm_pr_terminate
545 *
546 * PARAMETERS: <TBD>
547 *
548 * RETURN: <TBD>
549 *
550 * DESCRIPTION: <TBD>
551 *
552 ****************************************************************************/
553
554 ACPI_STATUS
555 bm_pr_terminate (void)
556 {
557 ACPI_STATUS status = AE_OK;
558 BM_DEVICE_ID criteria;
559 BM_DRIVER driver;
560
561 FUNCTION_TRACE("bm_pr_terminate");
562
563 MEMSET(&criteria, 0, sizeof(BM_DEVICE_ID));
564 MEMSET(&driver, 0, sizeof(BM_DRIVER));
565
566 criteria.type = BM_TYPE_POWER_RESOURCE;
567
568 driver.notify = &bm_pr_notify;
569 driver.request = &bm_pr_request;
570
571 status = bm_unregister_driver(&criteria, &driver);
572
573 return_ACPI_STATUS(status);
574 }
575
576
577 /****************************************************************************
578 *
579 * FUNCTION: bm_pr_notify
580 *
581 * PARAMETERS: <TBD>
582 *
583 * RETURN: <TBD>
584 *
585 * DESCRIPTION: <TBD>
586 *
587 ****************************************************************************/
588
589 ACPI_STATUS
590 bm_pr_notify (
591 BM_NOTIFY notify_type,
592 BM_HANDLE device_handle,
593 void **context)
594 {
595 ACPI_STATUS status = AE_OK;
596
597 FUNCTION_TRACE("bm_pr_notify");
598
599 switch (notify_type) {
600
601 case BM_NOTIFY_DEVICE_ADDED:
602 status = bm_pr_add_device(device_handle, context);
603 break;
604
605 case BM_NOTIFY_DEVICE_REMOVED:
606 status = bm_pr_remove_device(context);
607 break;
608
609 default:
610 status = AE_SUPPORT;
611 break;
612 }
613
614 return_ACPI_STATUS(status);
615 }
616
617
618 /****************************************************************************
619 *
620 * FUNCTION: bm_pr_request
621 *
622 * PARAMETERS: <TBD>
623 *
624 * RETURN: <TBD>
625 *
626 * DESCRIPTION: <TBD>
627 *
628 ****************************************************************************/
629
630 ACPI_STATUS
631 bm_pr_request (
632 BM_REQUEST *request,
633 void *context)
634 {
635 ACPI_STATUS status = AE_OK;
636 BM_POWER_RESOURCE *pr = NULL;
637
638 FUNCTION_TRACE("bm_pr_request");
639
640 /*
641 * Must have a valid request structure and context.
642 */
643 if (!request || !context) {
644 return_ACPI_STATUS(AE_BAD_PARAMETER);
645 }
646
647 /*
648 * context contains information specific to this power resource.
649 */
650 pr = (BM_POWER_RESOURCE*)context;
651
652 /*
653 * Handle request:
654 * ---------------
655 */
656 switch (request->command) {
657
658 default:
659 status = AE_SUPPORT;
660 break;
661 }
662
663 request->status = status;
664
665 return_ACPI_STATUS(status);
666 }
667
668
669
A free Windows-compatible Operating System