2 * acpi_power.c - ACPI Bus Power Management ($Revision: 39 $)
4 * Copyright (C) 2001, 2002 Andy Grover <andrew.grover@intel.com>
5 * Copyright (C) 2001, 2002 Paul Diefenbaugh <paul.s.diefenbaugh@intel.com>
7 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
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.
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.
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.
23 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
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.
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.
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>
48 #define _COMPONENT ACPI_POWER_COMPONENT
49 ACPI_MODULE_NAME ("acpi_power")
51 #define ACPI_POWER_COMPONENT 0x00800000
52 #define ACPI_POWER_CLASS "power_resource"
53 #define ACPI_POWER_DRIVER_NAME "ACPI Power Resource Driver"
54 #define ACPI_POWER_DEVICE_NAME "Power Resource"
55 #define ACPI_POWER_FILE_INFO "info"
56 #define ACPI_POWER_FILE_STATUS "state"
57 #define ACPI_POWER_RESOURCE_STATE_OFF 0x00
58 #define ACPI_POWER_RESOURCE_STATE_ON 0x01
59 #define ACPI_POWER_RESOURCE_STATE_UNKNOWN 0xFF
61 int acpi_power_add (struct acpi_device *device);
62 int acpi_power_remove (struct acpi_device *device, int type);
63 static int acpi_power_open_fs(struct inode *inode, struct file *file);
65 static struct acpi_driver acpi_power_driver = {
66 .name = ACPI_POWER_DRIVER_NAME,
67 .class = ACPI_POWER_CLASS,
68 .ids = ACPI_POWER_HID,
70 .add = acpi_power_add,
71 .remove = acpi_power_remove,
75 struct acpi_power_resource
85 static struct list_head acpi_power_resource_list;
87 static struct file_operations acpi_power_fops = {
88 .open = acpi_power_open_fs,
91 .release = single_release,
94 /* --------------------------------------------------------------------------
95 Power Resource Management
96 -------------------------------------------------------------------------- */
99 acpi_power_get_context (
101 struct acpi_power_resource **resource)
104 struct acpi_device *device = NULL;
106 ACPI_FUNCTION_TRACE("acpi_power_get_context");
109 return_VALUE(-ENODEV);
111 result = acpi_bus_get_device(handle, &device);
113 ACPI_DEBUG_PRINT((ACPI_DB_WARN, "Error getting context [%p]\n",
115 return_VALUE(result);
118 *resource = (struct acpi_power_resource *) acpi_driver_data(device);
120 return_VALUE(-ENODEV);
127 acpi_power_get_state (
128 struct acpi_power_resource *resource)
130 acpi_status status = AE_OK;
131 unsigned long sta = 0;
133 ACPI_FUNCTION_TRACE("acpi_power_get_state");
136 return_VALUE(-EINVAL);
138 status = acpi_evaluate_integer(resource->handle, "_STA", NULL, &sta);
139 if (ACPI_FAILURE(status))
140 return_VALUE(-ENODEV);
143 resource->state = ACPI_POWER_RESOURCE_STATE_ON;
145 resource->state = ACPI_POWER_RESOURCE_STATE_OFF;
147 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Resource [%s] is %s\n",
148 resource->name, resource->state?"on":"off"));
155 acpi_power_get_list_state (
156 struct acpi_handle_list *list,
160 struct acpi_power_resource *resource = NULL;
163 ACPI_FUNCTION_TRACE("acpi_power_get_list_state");
166 return_VALUE(-EINVAL);
168 /* The state of the list is 'on' IFF all resources are 'on'. */
170 for (i=0; i<list->count; i++) {
171 result = acpi_power_get_context(list->handles[i], &resource);
173 return_VALUE(result);
174 result = acpi_power_get_state(resource);
176 return_VALUE(result);
178 *state = resource->state;
180 if (*state != ACPI_POWER_RESOURCE_STATE_ON)
184 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Resource list is %s\n",
187 return_VALUE(result);
196 acpi_status status = AE_OK;
197 struct acpi_device *device = NULL;
198 struct acpi_power_resource *resource = NULL;
200 ACPI_FUNCTION_TRACE("acpi_power_on");
202 result = acpi_power_get_context(handle, &resource);
204 return_VALUE(result);
206 resource->references++;
208 if ((resource->references > 1)
209 || (resource->state == ACPI_POWER_RESOURCE_STATE_ON)) {
210 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Resource [%s] already on\n",
215 status = acpi_evaluate_object(resource->handle, "_ON", NULL, NULL);
216 if (ACPI_FAILURE(status))
217 return_VALUE(-ENODEV);
219 result = acpi_power_get_state(resource);
221 return_VALUE(result);
222 if (resource->state != ACPI_POWER_RESOURCE_STATE_ON)
223 return_VALUE(-ENOEXEC);
225 /* Update the power resource's _device_ power state */
226 result = acpi_bus_get_device(resource->handle, &device);
228 return_VALUE(result);
229 device->power.state = ACPI_STATE_D0;
231 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Resource [%s] turned on\n",
239 acpi_power_off_device (
243 acpi_status status = AE_OK;
244 struct acpi_device *device = NULL;
245 struct acpi_power_resource *resource = NULL;
247 ACPI_FUNCTION_TRACE("acpi_power_off_device");
249 result = acpi_power_get_context(handle, &resource);
251 return_VALUE(result);
253 if (resource->references)
254 resource->references--;
256 if (resource->references) {
257 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
258 "Resource [%s] is still in use, dereferencing\n",
259 device->pnp.bus_id));
263 if (resource->state == ACPI_POWER_RESOURCE_STATE_OFF) {
264 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Resource [%s] already off\n",
265 device->pnp.bus_id));
269 status = acpi_evaluate_object(resource->handle, "_OFF", NULL, NULL);
270 if (ACPI_FAILURE(status))
271 return_VALUE(-ENODEV);
273 result = acpi_power_get_state(resource);
275 return_VALUE(result);
276 if (resource->state != ACPI_POWER_RESOURCE_STATE_OFF)
277 return_VALUE(-ENOEXEC);
279 /* Update the power resource's _device_ power state */
280 result = acpi_bus_get_device(resource->handle, &device);
282 return_VALUE(result);
283 device->power.state = ACPI_STATE_D3;
285 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Resource [%s] turned off\n",
292 /* --------------------------------------------------------------------------
293 Device Power Management
294 -------------------------------------------------------------------------- */
297 acpi_power_get_inferred_state (
298 struct acpi_device *device)
301 struct acpi_handle_list *list = NULL;
305 ACPI_FUNCTION_TRACE("acpi_power_get_inferred_state");
308 return_VALUE(-EINVAL);
310 device->power.state = ACPI_STATE_UNKNOWN;
313 * We know a device's inferred power state when all the resources
314 * required for a given D-state are 'on'.
316 for (i=ACPI_STATE_D0; i<ACPI_STATE_D3; i++) {
317 list = &device->power.states[i].resources;
321 result = acpi_power_get_list_state(list, &list_state);
323 return_VALUE(result);
325 if (list_state == ACPI_POWER_RESOURCE_STATE_ON) {
326 device->power.state = i;
331 device->power.state = ACPI_STATE_D3;
338 acpi_power_transition (
339 struct acpi_device *device,
343 struct acpi_handle_list *cl = NULL; /* Current Resources */
344 struct acpi_handle_list *tl = NULL; /* Target Resources */
347 ACPI_FUNCTION_TRACE("acpi_power_transition");
349 if (!device || (state < ACPI_STATE_D0) || (state > ACPI_STATE_D3))
350 return_VALUE(-EINVAL);
352 if ((device->power.state < ACPI_STATE_D0) || (device->power.state > ACPI_STATE_D3))
353 return_VALUE(-ENODEV);
355 cl = &device->power.states[device->power.state].resources;
356 tl = &device->power.states[state].resources;
358 device->power.state = ACPI_STATE_UNKNOWN;
360 if (!cl->count && !tl->count) {
365 /* TBD: Resources must be ordered. */
368 * First we reference all power resources required in the target list
369 * (e.g. so the device doesn't lose power while transitioning).
371 for (i=0; i<tl->count; i++) {
372 result = acpi_power_on(tl->handles[i]);
378 * Then we dereference all power resources used in the current list.
380 for (i=0; i<cl->count; i++) {
381 result = acpi_power_off_device(cl->handles[i]);
386 /* We shouldn't change the state till all above operations succeed */
387 device->power.state = state;
390 ACPI_DEBUG_PRINT((ACPI_DB_WARN,
391 "Error transitioning device [%s] to D%d\n",
392 device->pnp.bus_id, state));
394 return_VALUE(result);
398 /* --------------------------------------------------------------------------
400 -------------------------------------------------------------------------- */
402 struct proc_dir_entry *acpi_power_dir;
404 static int acpi_power_seq_show(struct seq_file *seq, void *offset)
406 struct acpi_power_resource *resource = NULL;
408 ACPI_FUNCTION_TRACE("acpi_power_seq_show");
410 resource = (struct acpi_power_resource *)seq->private;
415 seq_puts(seq, "state: ");
416 switch (resource->state) {
417 case ACPI_POWER_RESOURCE_STATE_ON:
418 seq_puts(seq, "on\n");
420 case ACPI_POWER_RESOURCE_STATE_OFF:
421 seq_puts(seq, "off\n");
424 seq_puts(seq, "unknown\n");
428 seq_printf(seq, "system level: S%d\n"
430 "reference count: %d\n",
431 resource->system_level,
433 resource->references);
439 static int acpi_power_open_fs(struct inode *inode, struct file *file)
441 return single_open(file, acpi_power_seq_show, PDE(inode)->data);
446 struct acpi_device *device)
448 struct proc_dir_entry *entry = NULL;
450 ACPI_FUNCTION_TRACE("acpi_power_add_fs");
453 return_VALUE(-EINVAL);
455 if (!acpi_device_dir(device)) {
456 acpi_device_dir(device) = proc_mkdir(acpi_device_bid(device),
458 if (!acpi_device_dir(device))
459 return_VALUE(-ENODEV);
463 entry = create_proc_entry(ACPI_POWER_FILE_STATUS,
464 S_IRUGO, acpi_device_dir(device));
466 ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
467 "Unable to create '%s' fs entry\n",
468 ACPI_POWER_FILE_STATUS));
470 entry->proc_fops = &acpi_power_fops;
471 entry->data = acpi_driver_data(device);
479 acpi_power_remove_fs (
480 struct acpi_device *device)
482 ACPI_FUNCTION_TRACE("acpi_power_remove_fs");
484 if (acpi_device_dir(device)) {
485 remove_proc_entry(ACPI_POWER_FILE_STATUS,
486 acpi_device_dir(device));
487 remove_proc_entry(acpi_device_bid(device), acpi_power_dir);
488 acpi_device_dir(device) = NULL;
495 /* --------------------------------------------------------------------------
497 -------------------------------------------------------------------------- */
501 struct acpi_device *device)
504 acpi_status status = AE_OK;
505 struct acpi_power_resource *resource = NULL;
506 union acpi_object acpi_object;
507 struct acpi_buffer buffer = {sizeof(acpi_object), &acpi_object};
509 ACPI_FUNCTION_TRACE("acpi_power_add");
512 return_VALUE(-EINVAL);
514 resource = kmalloc(sizeof(struct acpi_power_resource), GFP_KERNEL);
516 return_VALUE(-ENOMEM);
517 memset(resource, 0, sizeof(struct acpi_power_resource));
519 resource->handle = device->handle;
520 strcpy(resource->name, device->pnp.bus_id);
521 strcpy(acpi_device_name(device), ACPI_POWER_DEVICE_NAME);
522 strcpy(acpi_device_class(device), ACPI_POWER_CLASS);
523 acpi_driver_data(device) = resource;
525 /* Evalute the object to get the system level and resource order. */
526 status = acpi_evaluate_object(resource->handle, NULL, NULL, &buffer);
527 if (ACPI_FAILURE(status)) {
531 resource->system_level = acpi_object.power_resource.system_level;
532 resource->order = acpi_object.power_resource.resource_order;
534 result = acpi_power_get_state(resource);
538 switch (resource->state) {
539 case ACPI_POWER_RESOURCE_STATE_ON:
540 device->power.state = ACPI_STATE_D0;
542 case ACPI_POWER_RESOURCE_STATE_OFF:
543 device->power.state = ACPI_STATE_D3;
546 device->power.state = ACPI_STATE_UNKNOWN;
550 result = acpi_power_add_fs(device);
554 printk(KERN_INFO PREFIX "%s [%s] (%s)\n", acpi_device_name(device),
555 acpi_device_bid(device), resource->state?"on":"off");
561 return_VALUE(result);
567 struct acpi_device *device,
570 struct acpi_power_resource *resource = NULL;
572 ACPI_FUNCTION_TRACE("acpi_power_remove");
574 if (!device || !acpi_driver_data(device))
575 return_VALUE(-EINVAL);
577 resource = (struct acpi_power_resource *) acpi_driver_data(device);
579 acpi_power_remove_fs(device);
587 static int __init acpi_power_init (void)
591 ACPI_FUNCTION_TRACE("acpi_power_init");
596 INIT_LIST_HEAD(&acpi_power_resource_list);
598 acpi_power_dir = proc_mkdir(ACPI_POWER_CLASS, acpi_root_dir);
600 return_VALUE(-ENODEV);
602 result = acpi_bus_register_driver(&acpi_power_driver);
604 remove_proc_entry(ACPI_POWER_CLASS, acpi_root_dir);
605 return_VALUE(-ENODEV);
611 subsys_initcall(acpi_power_init);