ACPI / scan: Remove unnecessary initialization of local variables
[linux-3.10.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/slab.h>
43 #include <linux/pm_runtime.h>
44 #include <acpi/acpi_bus.h>
45 #include <acpi/acpi_drivers.h>
46 #include "sleep.h"
47 #include "internal.h"
48
49 #define PREFIX "ACPI: "
50
51 #define _COMPONENT                      ACPI_POWER_COMPONENT
52 ACPI_MODULE_NAME("power");
53 #define ACPI_POWER_CLASS                "power_resource"
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
60
61 struct acpi_power_dependent_device {
62         struct list_head node;
63         struct acpi_device *adev;
64         struct work_struct work;
65 };
66
67 struct acpi_power_resource {
68         struct acpi_device device;
69         struct list_head list_node;
70         struct list_head dependent;
71         char *name;
72         u32 system_level;
73         u32 order;
74         unsigned int ref_count;
75         struct mutex resource_lock;
76 };
77
78 struct acpi_power_resource_entry {
79         struct list_head node;
80         struct acpi_power_resource *resource;
81 };
82
83 static LIST_HEAD(acpi_power_resource_list);
84 static DEFINE_MUTEX(power_resource_list_lock);
85
86 /* --------------------------------------------------------------------------
87                              Power Resource Management
88    -------------------------------------------------------------------------- */
89
90 static struct acpi_power_resource *acpi_power_get_context(acpi_handle handle)
91 {
92         struct acpi_device *device;
93
94         if (acpi_bus_get_device(handle, &device))
95                 return NULL;
96
97         return container_of(device, struct acpi_power_resource, device);
98 }
99
100 void acpi_power_resources_list_add(acpi_handle handle, struct list_head *list)
101 {
102         struct acpi_power_resource *resource = acpi_power_get_context(handle);
103         struct acpi_power_resource_entry *entry;
104
105         if (!resource || !list)
106                 return;
107
108         entry = kzalloc(sizeof(*entry), GFP_KERNEL);
109         if (!entry)
110                 return;
111
112         entry->resource = resource;
113         if (!list_empty(list)) {
114                 struct acpi_power_resource_entry *e;
115
116                 list_for_each_entry(e, list, node)
117                         if (e->resource->order > resource->order) {
118                                 list_add_tail(&entry->node, &e->node);
119                                 return;
120                         }
121         }
122         list_add_tail(&entry->node, list);
123 }
124
125 void acpi_power_resources_list_free(struct list_head *list)
126 {
127         struct acpi_power_resource_entry *entry, *e;
128
129         list_for_each_entry_safe(entry, e, list, node) {
130                 list_del(&entry->node);
131                 kfree(entry);
132         }
133 }
134
135 static int acpi_power_get_state(acpi_handle handle, int *state)
136 {
137         acpi_status status = AE_OK;
138         unsigned long long sta = 0;
139         char node_name[5];
140         struct acpi_buffer buffer = { sizeof(node_name), node_name };
141
142
143         if (!handle || !state)
144                 return -EINVAL;
145
146         status = acpi_evaluate_integer(handle, "_STA", NULL, &sta);
147         if (ACPI_FAILURE(status))
148                 return -ENODEV;
149
150         *state = (sta & 0x01)?ACPI_POWER_RESOURCE_STATE_ON:
151                               ACPI_POWER_RESOURCE_STATE_OFF;
152
153         acpi_get_name(handle, ACPI_SINGLE_NAME, &buffer);
154
155         ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Resource [%s] is %s\n",
156                           node_name,
157                                 *state ? "on" : "off"));
158
159         return 0;
160 }
161
162 static int acpi_power_get_list_state(struct list_head *list, int *state)
163 {
164         struct acpi_power_resource_entry *entry;
165         int cur_state;
166
167         if (!list || !state)
168                 return -EINVAL;
169
170         /* The state of the list is 'on' IFF all resources are 'on'. */
171         list_for_each_entry(entry, list, node) {
172                 struct acpi_power_resource *resource = entry->resource;
173                 acpi_handle handle = resource->device.handle;
174                 int result;
175
176                 mutex_lock(&resource->resource_lock);
177                 result = acpi_power_get_state(handle, &cur_state);
178                 mutex_unlock(&resource->resource_lock);
179                 if (result)
180                         return result;
181
182                 if (cur_state != ACPI_POWER_RESOURCE_STATE_ON)
183                         break;
184         }
185
186         ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Resource list is %s\n",
187                           cur_state ? "on" : "off"));
188
189         *state = cur_state;
190         return 0;
191 }
192
193 static void acpi_power_resume_dependent(struct work_struct *work)
194 {
195         struct acpi_power_dependent_device *dep;
196         struct acpi_device_physical_node *pn;
197         struct acpi_device *adev;
198         int state;
199
200         dep = container_of(work, struct acpi_power_dependent_device, work);
201         adev = dep->adev;
202         if (acpi_power_get_inferred_state(adev, &state))
203                 return;
204
205         if (state > ACPI_STATE_D0)
206                 return;
207
208         mutex_lock(&adev->physical_node_lock);
209
210         list_for_each_entry(pn, &adev->physical_node_list, node)
211                 pm_request_resume(pn->dev);
212
213         list_for_each_entry(pn, &adev->power_dependent, node)
214                 pm_request_resume(pn->dev);
215
216         mutex_unlock(&adev->physical_node_lock);
217 }
218
219 static int __acpi_power_on(struct acpi_power_resource *resource)
220 {
221         acpi_status status = AE_OK;
222
223         status = acpi_evaluate_object(resource->device.handle, "_ON", NULL, NULL);
224         if (ACPI_FAILURE(status))
225                 return -ENODEV;
226
227         ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Power resource [%s] turned on\n",
228                           resource->name));
229
230         return 0;
231 }
232
233 static int acpi_power_on(struct acpi_power_resource *resource)
234 {
235         int result = 0;;
236
237         mutex_lock(&resource->resource_lock);
238
239         if (resource->ref_count++) {
240                 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
241                                   "Power resource [%s] already on",
242                                   resource->name));
243         } else {
244                 result = __acpi_power_on(resource);
245                 if (result) {
246                         resource->ref_count--;
247                 } else {
248                         struct acpi_power_dependent_device *dep;
249
250                         list_for_each_entry(dep, &resource->dependent, node)
251                                 schedule_work(&dep->work);
252                 }
253         }
254
255         mutex_unlock(&resource->resource_lock);
256
257         return result;
258 }
259
260 static int acpi_power_off(struct acpi_power_resource *resource)
261 {
262         acpi_status status = AE_OK;
263         int result = 0;
264
265         mutex_lock(&resource->resource_lock);
266
267         if (!resource->ref_count) {
268                 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
269                                   "Power resource [%s] already off",
270                                   resource->name));
271                 goto unlock;
272         }
273
274         if (--resource->ref_count) {
275                 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
276                                   "Power resource [%s] still in use\n",
277                                   resource->name));
278                 goto unlock;
279         }
280
281         status = acpi_evaluate_object(resource->device.handle, "_OFF", NULL, NULL);
282         if (ACPI_FAILURE(status))
283                 result = -ENODEV;
284         else
285                 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
286                                   "Power resource [%s] turned off\n",
287                                   resource->name));
288
289  unlock:
290         mutex_unlock(&resource->resource_lock);
291
292         return result;
293 }
294
295 static int acpi_power_off_list(struct list_head *list)
296 {
297         struct acpi_power_resource_entry *entry;
298         int result = 0;
299
300         list_for_each_entry_reverse(entry, list, node) {
301                 result = acpi_power_off(entry->resource);
302                 if (result)
303                         goto err;
304         }
305         return 0;
306
307  err:
308         list_for_each_entry_continue(entry, list, node)
309                 acpi_power_on(entry->resource);
310
311         return result;
312 }
313
314 static int acpi_power_on_list(struct list_head *list)
315 {
316         struct acpi_power_resource_entry *entry;
317         int result = 0;
318
319         list_for_each_entry(entry, list, node) {
320                 result = acpi_power_on(entry->resource);
321                 if (result)
322                         goto err;
323         }
324         return 0;
325
326  err:
327         list_for_each_entry_continue_reverse(entry, list, node)
328                 acpi_power_off(entry->resource);
329
330         return result;
331 }
332
333 static void acpi_power_add_dependent(struct acpi_power_resource *resource,
334                                      struct acpi_device *adev)
335 {
336         struct acpi_power_dependent_device *dep;
337
338         mutex_lock(&resource->resource_lock);
339
340         list_for_each_entry(dep, &resource->dependent, node)
341                 if (dep->adev == adev)
342                         goto out;
343
344         dep = kzalloc(sizeof(*dep), GFP_KERNEL);
345         if (!dep)
346                 goto out;
347
348         dep->adev = adev;
349         INIT_WORK(&dep->work, acpi_power_resume_dependent);
350         list_add_tail(&dep->node, &resource->dependent);
351
352  out:
353         mutex_unlock(&resource->resource_lock);
354 }
355
356 static void acpi_power_remove_dependent(struct acpi_power_resource *resource,
357                                         struct acpi_device *adev)
358 {
359         struct acpi_power_dependent_device *dep;
360         struct work_struct *work = NULL;
361
362         mutex_lock(&resource->resource_lock);
363
364         list_for_each_entry(dep, &resource->dependent, node)
365                 if (dep->adev == adev) {
366                         list_del(&dep->node);
367                         work = &dep->work;
368                         break;
369                 }
370
371         mutex_unlock(&resource->resource_lock);
372
373         if (work) {
374                 cancel_work_sync(work);
375                 kfree(dep);
376         }
377 }
378
379 void acpi_power_add_remove_device(struct acpi_device *adev, bool add)
380 {
381         if (adev->power.flags.power_resources) {
382                 struct acpi_device_power_state *ps;
383                 struct acpi_power_resource_entry *entry;
384
385                 ps = &adev->power.states[ACPI_STATE_D0];
386                 list_for_each_entry(entry, &ps->resources, node) {
387                         struct acpi_power_resource *resource = entry->resource;
388
389                         if (add)
390                                 acpi_power_add_dependent(resource, adev);
391                         else
392                                 acpi_power_remove_dependent(resource, adev);
393                 }
394         }
395 }
396
397 /* --------------------------------------------------------------------------
398                              Device Power Management
399    -------------------------------------------------------------------------- */
400
401 /**
402  * acpi_device_sleep_wake - execute _DSW (Device Sleep Wake) or (deprecated in
403  *                          ACPI 3.0) _PSW (Power State Wake)
404  * @dev: Device to handle.
405  * @enable: 0 - disable, 1 - enable the wake capabilities of the device.
406  * @sleep_state: Target sleep state of the system.
407  * @dev_state: Target power state of the device.
408  *
409  * Execute _DSW (Device Sleep Wake) or (deprecated in ACPI 3.0) _PSW (Power
410  * State Wake) for the device, if present.  On failure reset the device's
411  * wakeup.flags.valid flag.
412  *
413  * RETURN VALUE:
414  * 0 if either _DSW or _PSW has been successfully executed
415  * 0 if neither _DSW nor _PSW has been found
416  * -ENODEV if the execution of either _DSW or _PSW has failed
417  */
418 int acpi_device_sleep_wake(struct acpi_device *dev,
419                            int enable, int sleep_state, int dev_state)
420 {
421         union acpi_object in_arg[3];
422         struct acpi_object_list arg_list = { 3, in_arg };
423         acpi_status status = AE_OK;
424
425         /*
426          * Try to execute _DSW first.
427          *
428          * Three agruments are needed for the _DSW object:
429          * Argument 0: enable/disable the wake capabilities
430          * Argument 1: target system state
431          * Argument 2: target device state
432          * When _DSW object is called to disable the wake capabilities, maybe
433          * the first argument is filled. The values of the other two agruments
434          * are meaningless.
435          */
436         in_arg[0].type = ACPI_TYPE_INTEGER;
437         in_arg[0].integer.value = enable;
438         in_arg[1].type = ACPI_TYPE_INTEGER;
439         in_arg[1].integer.value = sleep_state;
440         in_arg[2].type = ACPI_TYPE_INTEGER;
441         in_arg[2].integer.value = dev_state;
442         status = acpi_evaluate_object(dev->handle, "_DSW", &arg_list, NULL);
443         if (ACPI_SUCCESS(status)) {
444                 return 0;
445         } else if (status != AE_NOT_FOUND) {
446                 printk(KERN_ERR PREFIX "_DSW execution failed\n");
447                 dev->wakeup.flags.valid = 0;
448                 return -ENODEV;
449         }
450
451         /* Execute _PSW */
452         arg_list.count = 1;
453         in_arg[0].integer.value = enable;
454         status = acpi_evaluate_object(dev->handle, "_PSW", &arg_list, NULL);
455         if (ACPI_FAILURE(status) && (status != AE_NOT_FOUND)) {
456                 printk(KERN_ERR PREFIX "_PSW execution failed\n");
457                 dev->wakeup.flags.valid = 0;
458                 return -ENODEV;
459         }
460
461         return 0;
462 }
463
464 /*
465  * Prepare a wakeup device, two steps (Ref ACPI 2.0:P229):
466  * 1. Power on the power resources required for the wakeup device 
467  * 2. Execute _DSW (Device Sleep Wake) or (deprecated in ACPI 3.0) _PSW (Power
468  *    State Wake) for the device, if present
469  */
470 int acpi_enable_wakeup_device_power(struct acpi_device *dev, int sleep_state)
471 {
472         int err = 0;
473
474         if (!dev || !dev->wakeup.flags.valid)
475                 return -EINVAL;
476
477         mutex_lock(&acpi_device_lock);
478
479         if (dev->wakeup.prepare_count++)
480                 goto out;
481
482         err = acpi_power_on_list(&dev->wakeup.resources);
483         if (err) {
484                 dev_err(&dev->dev, "Cannot turn wakeup power resources on\n");
485                 dev->wakeup.flags.valid = 0;
486         } else {
487                 /*
488                  * Passing 3 as the third argument below means the device may be
489                  * put into arbitrary power state afterward.
490                  */
491                 err = acpi_device_sleep_wake(dev, 1, sleep_state, 3);
492         }
493         if (err)
494                 dev->wakeup.prepare_count = 0;
495
496  out:
497         mutex_unlock(&acpi_device_lock);
498         return err;
499 }
500
501 /*
502  * Shutdown a wakeup device, counterpart of above method
503  * 1. Execute _DSW (Device Sleep Wake) or (deprecated in ACPI 3.0) _PSW (Power
504  *    State Wake) for the device, if present
505  * 2. Shutdown down the power resources
506  */
507 int acpi_disable_wakeup_device_power(struct acpi_device *dev)
508 {
509         int err = 0;
510
511         if (!dev || !dev->wakeup.flags.valid)
512                 return -EINVAL;
513
514         mutex_lock(&acpi_device_lock);
515
516         if (--dev->wakeup.prepare_count > 0)
517                 goto out;
518
519         /*
520          * Executing the code below even if prepare_count is already zero when
521          * the function is called may be useful, for example for initialisation.
522          */
523         if (dev->wakeup.prepare_count < 0)
524                 dev->wakeup.prepare_count = 0;
525
526         err = acpi_device_sleep_wake(dev, 0, 0, 0);
527         if (err)
528                 goto out;
529
530         err = acpi_power_off_list(&dev->wakeup.resources);
531         if (err) {
532                 dev_err(&dev->dev, "Cannot turn wakeup power resources off\n");
533                 dev->wakeup.flags.valid = 0;
534         }
535
536  out:
537         mutex_unlock(&acpi_device_lock);
538         return err;
539 }
540
541 int acpi_power_get_inferred_state(struct acpi_device *device, int *state)
542 {
543         int result = 0;
544         int list_state = 0;
545         int i = 0;
546
547         if (!device || !state)
548                 return -EINVAL;
549
550         /*
551          * We know a device's inferred power state when all the resources
552          * required for a given D-state are 'on'.
553          */
554         for (i = ACPI_STATE_D0; i <= ACPI_STATE_D3_HOT; i++) {
555                 struct list_head *list = &device->power.states[i].resources;
556
557                 if (list_empty(list))
558                         continue;
559
560                 result = acpi_power_get_list_state(list, &list_state);
561                 if (result)
562                         return result;
563
564                 if (list_state == ACPI_POWER_RESOURCE_STATE_ON) {
565                         *state = i;
566                         return 0;
567                 }
568         }
569
570         *state = ACPI_STATE_D3;
571         return 0;
572 }
573
574 int acpi_power_on_resources(struct acpi_device *device, int state)
575 {
576         if (!device || state < ACPI_STATE_D0 || state > ACPI_STATE_D3_COLD)
577                 return -EINVAL;
578
579         if (state == ACPI_STATE_D3_COLD)
580                 return 0;
581
582         return acpi_power_on_list(&device->power.states[state].resources);
583 }
584
585 int acpi_power_transition(struct acpi_device *device, int state)
586 {
587         int result = 0;
588
589         if (!device || (state < ACPI_STATE_D0) || (state > ACPI_STATE_D3_COLD))
590                 return -EINVAL;
591
592         if (device->power.state == state || !device->flags.power_manageable)
593                 return 0;
594
595         if ((device->power.state < ACPI_STATE_D0)
596             || (device->power.state > ACPI_STATE_D3_COLD))
597                 return -ENODEV;
598
599         /* TBD: Resources must be ordered. */
600
601         /*
602          * First we reference all power resources required in the target list
603          * (e.g. so the device doesn't lose power while transitioning).  Then,
604          * we dereference all power resources used in the current list.
605          */
606         if (state < ACPI_STATE_D3_COLD)
607                 result = acpi_power_on_list(
608                         &device->power.states[state].resources);
609
610         if (!result && device->power.state < ACPI_STATE_D3_COLD)
611                 acpi_power_off_list(
612                         &device->power.states[device->power.state].resources);
613
614         /* We shouldn't change the state unless the above operations succeed. */
615         device->power.state = result ? ACPI_STATE_UNKNOWN : state;
616
617         return result;
618 }
619
620 static void acpi_release_power_resource(struct device *dev)
621 {
622         struct acpi_device *device = to_acpi_device(dev);
623         struct acpi_power_resource *resource;
624
625         resource = container_of(device, struct acpi_power_resource, device);
626
627         mutex_lock(&power_resource_list_lock);
628         list_del(&resource->list_node);
629         mutex_unlock(&power_resource_list_lock);
630
631         acpi_free_ids(device);
632         kfree(resource);
633 }
634
635 void acpi_add_power_resource(acpi_handle handle)
636 {
637         struct acpi_power_resource *resource;
638         struct acpi_device *device = NULL;
639         union acpi_object acpi_object;
640         struct acpi_buffer buffer = { sizeof(acpi_object), &acpi_object };
641         acpi_status status;
642         int state, result = -ENODEV;
643
644         acpi_bus_get_device(handle, &device);
645         if (device)
646                 return;
647
648         resource = kzalloc(sizeof(*resource), GFP_KERNEL);
649         if (!resource)
650                 return;
651
652         device = &resource->device;
653         acpi_init_device_object(device, handle, ACPI_BUS_TYPE_POWER,
654                                 ACPI_STA_DEFAULT);
655         mutex_init(&resource->resource_lock);
656         INIT_LIST_HEAD(&resource->dependent);
657         resource->name = device->pnp.bus_id;
658         strcpy(acpi_device_name(device), ACPI_POWER_DEVICE_NAME);
659         strcpy(acpi_device_class(device), ACPI_POWER_CLASS);
660         device->power.state = ACPI_STATE_UNKNOWN;
661
662         /* Evalute the object to get the system level and resource order. */
663         status = acpi_evaluate_object(handle, NULL, NULL, &buffer);
664         if (ACPI_FAILURE(status))
665                 goto err;
666
667         resource->system_level = acpi_object.power_resource.system_level;
668         resource->order = acpi_object.power_resource.resource_order;
669
670         result = acpi_power_get_state(handle, &state);
671         if (result)
672                 goto err;
673
674         printk(KERN_INFO PREFIX "%s [%s] (%s)\n", acpi_device_name(device),
675                acpi_device_bid(device), state ? "on" : "off");
676
677         device->flags.match_driver = true;
678         result = acpi_device_register(device, acpi_release_power_resource);
679         if (result)
680                 goto err;
681
682         mutex_lock(&power_resource_list_lock);
683         list_add(&resource->list_node, &acpi_power_resource_list);
684         mutex_unlock(&power_resource_list_lock);
685         return;
686
687  err:
688         acpi_release_power_resource(&device->dev);
689 }
690
691 #ifdef CONFIG_ACPI_SLEEP
692 void acpi_resume_power_resources(void)
693 {
694         struct acpi_power_resource *resource;
695
696         mutex_lock(&power_resource_list_lock);
697
698         list_for_each_entry(resource, &acpi_power_resource_list, list_node) {
699                 int result, state;
700
701                 mutex_lock(&resource->resource_lock);
702
703                 result = acpi_power_get_state(resource->device.handle, &state);
704                 if (!result && state == ACPI_POWER_RESOURCE_STATE_OFF
705                     && resource->ref_count) {
706                         dev_info(&resource->device.dev, "Turning ON\n");
707                         __acpi_power_on(resource);
708                 }
709
710                 mutex_unlock(&resource->resource_lock);
711         }
712
713         mutex_unlock(&power_resource_list_lock);
714 }
715 #endif