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