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