drivers/acpi/wakeup.c

   1 /*
   2  * wakeup.c - support wakeup devices
   3  * Copyright (C) 2004 Li Shaohua <shaohua.li@intel.com>
   4  */
   5
   6 #include <linux/init.h>
   7 #include <linux/acpi.h>
   8 #include <acpi/acpi_drivers.h>
   9 #include <linux/kernel.h>
  10 #include <linux/types.h>
  11 #include "sleep.h"
  12
  13 #define _COMPONENT              ACPI_SYSTEM_COMPONENT
  14 ACPI_MODULE_NAME("wakeup_devices")
  15
  16 extern struct list_head acpi_wakeup_device_list;
  17 extern spinlock_t acpi_device_lock;
  18
  19 /**
  20  * acpi_enable_wakeup_device_prep - prepare wakeup devices
  21  *      @sleep_state:   ACPI state
  22  * Enable all wakup devices power if the devices' wakeup level
  23  * is higher than requested sleep level
  24  */
  25
  26 void acpi_enable_wakeup_device_prep(u8 sleep_state)
  27 {
  28         struct list_head *node, *next;
  29
  30         spin_lock(&acpi_device_lock);
  31         list_for_each_safe(node, next, &acpi_wakeup_device_list) {
  32                 struct acpi_device *dev = container_of(node,
  33                                                        struct acpi_device,
  34                                                        wakeup_list);
  35
  36                 if (!dev->wakeup.flags.valid ||
  37                     !dev->wakeup.state.enabled ||
  38                     (sleep_state > (u32) dev->wakeup.sleep_state))
  39                         continue;
  40
  41                 spin_unlock(&acpi_device_lock);
  42                 acpi_enable_wakeup_device_power(dev, sleep_state);
  43                 spin_lock(&acpi_device_lock);
  44         }
  45         spin_unlock(&acpi_device_lock);
  46 }
  47
  48 /**
  49  * acpi_enable_wakeup_device - enable wakeup devices
  50  *      @sleep_state:   ACPI state
  51  * Enable all wakup devices's GPE
  52  */
  53 void acpi_enable_wakeup_device(u8 sleep_state)
  54 {
  55         struct list_head *node, *next;
  56
  57         /*
  58          * Caution: this routine must be invoked when interrupt is disabled
  59          * Refer ACPI2.0: P212
  60          */
  61         spin_lock(&acpi_device_lock);
  62         list_for_each_safe(node, next, &acpi_wakeup_device_list) {
  63                 struct acpi_device *dev =
  64                         container_of(node, struct acpi_device, wakeup_list);
  65
  66                 if (!dev->wakeup.flags.valid)
  67                         continue;
  68
  69                 /* If users want to disable run-wake GPE,
  70                  * we only disable it for wake and leave it for runtime
  71                  */
  72                 if ((!dev->wakeup.state.enabled && !dev->wakeup.flags.prepared)
  73                     || sleep_state > (u32) dev->wakeup.sleep_state) {
  74                         if (dev->wakeup.flags.run_wake) {
  75                                 spin_unlock(&acpi_device_lock);
  76                                 /* set_gpe_type will disable GPE, leave it like that */
  77                                 acpi_set_gpe_type(dev->wakeup.gpe_device,
  78                                                   dev->wakeup.gpe_number,
  79                                                   ACPI_GPE_TYPE_RUNTIME);
  80                                 spin_lock(&acpi_device_lock);
  81                         }
  82                         continue;
  83                 }
  84                 spin_unlock(&acpi_device_lock);
  85                 if (!dev->wakeup.flags.run_wake)
  86                         acpi_enable_gpe(dev->wakeup.gpe_device,
  87                                         dev->wakeup.gpe_number);
  88                 spin_lock(&acpi_device_lock);
  89         }
  90         spin_unlock(&acpi_device_lock);
  91 }
  92
  93 /**
  94  * acpi_disable_wakeup_device - disable devices' wakeup capability
  95  *      @sleep_state:   ACPI state
  96  * Disable all wakup devices's GPE and wakeup capability
  97  */
  98 void acpi_disable_wakeup_device(u8 sleep_state)
  99 {
 100         struct list_head *node, *next;
 101
 102         spin_lock(&acpi_device_lock);
 103         list_for_each_safe(node, next, &acpi_wakeup_device_list) {
 104                 struct acpi_device *dev =
 105                         container_of(node, struct acpi_device, wakeup_list);
 106
 107                 if (!dev->wakeup.flags.valid)
 108                         continue;
 109
 110                 if ((!dev->wakeup.state.enabled && !dev->wakeup.flags.prepared)
 111                     || sleep_state > (u32) dev->wakeup.sleep_state) {
 112                         if (dev->wakeup.flags.run_wake) {
 113                                 spin_unlock(&acpi_device_lock);
 114                                 acpi_set_gpe_type(dev->wakeup.gpe_device,
 115                                                   dev->wakeup.gpe_number,
 116                                                   ACPI_GPE_TYPE_WAKE_RUN);
 117                                 /* Re-enable it, since set_gpe_type will disable it */
 118                                 acpi_enable_gpe(dev->wakeup.gpe_device,
 119                                                 dev->wakeup.gpe_number);
 120                                 spin_lock(&acpi_device_lock);
 121                         }
 122                         continue;
 123                 }
 124
 125                 spin_unlock(&acpi_device_lock);
 126                 acpi_disable_wakeup_device_power(dev);
 127                 /* Never disable run-wake GPE */
 128                 if (!dev->wakeup.flags.run_wake) {
 129                         acpi_disable_gpe(dev->wakeup.gpe_device,
 130                                          dev->wakeup.gpe_number);
 131                         acpi_clear_gpe(dev->wakeup.gpe_device,
 132                                        dev->wakeup.gpe_number, ACPI_NOT_ISR);
 133                 }
 134                 spin_lock(&acpi_device_lock);
 135         }
 136         spin_unlock(&acpi_device_lock);
 137 }
 138
 139 static int __init acpi_wakeup_device_init(void)
 140 {
 141         struct list_head *node, *next;
 142
 143         if (acpi_disabled)
 144                 return 0;
 145
 146         spin_lock(&acpi_device_lock);
 147         list_for_each_safe(node, next, &acpi_wakeup_device_list) {
 148                 struct acpi_device *dev = container_of(node,
 149                                                        struct acpi_device,
 150                                                        wakeup_list);
 151                 /* In case user doesn't load button driver */
 152                 if (!dev->wakeup.flags.run_wake || dev->wakeup.state.enabled)
 153                         continue;
 154                 spin_unlock(&acpi_device_lock);
 155                 acpi_set_gpe_type(dev->wakeup.gpe_device,
 156                                   dev->wakeup.gpe_number,
 157                                   ACPI_GPE_TYPE_WAKE_RUN);
 158                 acpi_enable_gpe(dev->wakeup.gpe_device,
 159                                 dev->wakeup.gpe_number);
 160                 dev->wakeup.state.enabled = 1;
 161                 spin_lock(&acpi_device_lock);
 162         }
 163         spin_unlock(&acpi_device_lock);
 164         return 0;
 165 }
 166
 167 late_initcall(acpi_wakeup_device_init);