drivers/acpi/wakeup.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * wakeup.c - support wakeup devices
   4  * Copyright (C) 2004 Li Shaohua <shaohua.li@intel.com>
   5  */
   6
   7 #include <linux/init.h>
   8 #include <linux/acpi.h>
   9 #include <linux/kernel.h>
  10 #include <linux/types.h>
  11
  12 #include "internal.h"
  13 #include "sleep.h"
  14
  15 struct acpi_wakeup_handler {
  16         struct list_head list_node;
  17         bool (*wakeup)(void *context);
  18         void *context;
  19 };
  20
  21 static LIST_HEAD(acpi_wakeup_handler_head);
  22 static DEFINE_MUTEX(acpi_wakeup_handler_mutex);
  23
  24 /*
  25  * We didn't lock acpi_device_lock in the file, because it invokes oops in
  26  * suspend/resume and isn't really required as this is called in S-state. At
  27  * that time, there is no device hotplug
  28  **/
  29
  30 /**
  31  * acpi_enable_wakeup_devices - Enable wake-up device GPEs.
  32  * @sleep_state: ACPI system sleep state.
  33  *
  34  * Enable wakeup device power of devices with the state.enable flag set and set
  35  * the wakeup enable mask bits in the GPE registers that correspond to wakeup
  36  * devices.
  37  */
  38 void acpi_enable_wakeup_devices(u8 sleep_state)
  39 {
  40         struct acpi_device *dev, *tmp;
  41
  42         list_for_each_entry_safe(dev, tmp, &acpi_wakeup_device_list,
  43                                  wakeup_list) {
  44                 if (!dev->wakeup.flags.valid
  45                     || sleep_state > (u32) dev->wakeup.sleep_state
  46                     || !(device_may_wakeup(&dev->dev)
  47                          || dev->wakeup.prepare_count))
  48                         continue;
  49
  50                 if (device_may_wakeup(&dev->dev))
  51                         acpi_enable_wakeup_device_power(dev, sleep_state);
  52
  53                 /* The wake-up power should have been enabled already. */
  54                 acpi_set_gpe_wake_mask(dev->wakeup.gpe_device, dev->wakeup.gpe_number,
  55                                 ACPI_GPE_ENABLE);
  56         }
  57 }
  58
  59 /**
  60  * acpi_disable_wakeup_devices - Disable devices' wakeup capability.
  61  * @sleep_state: ACPI system sleep state.
  62  */
  63 void acpi_disable_wakeup_devices(u8 sleep_state)
  64 {
  65         struct acpi_device *dev, *tmp;
  66
  67         list_for_each_entry_safe(dev, tmp, &acpi_wakeup_device_list,
  68                                  wakeup_list) {
  69                 if (!dev->wakeup.flags.valid
  70                     || sleep_state > (u32) dev->wakeup.sleep_state
  71                     || !(device_may_wakeup(&dev->dev)
  72                          || dev->wakeup.prepare_count))
  73                         continue;
  74
  75                 acpi_set_gpe_wake_mask(dev->wakeup.gpe_device, dev->wakeup.gpe_number,
  76                                 ACPI_GPE_DISABLE);
  77
  78                 if (device_may_wakeup(&dev->dev))
  79                         acpi_disable_wakeup_device_power(dev);
  80         }
  81 }
  82
  83 int __init acpi_wakeup_device_init(void)
  84 {
  85         struct acpi_device *dev, *tmp;
  86
  87         mutex_lock(&acpi_device_lock);
  88         list_for_each_entry_safe(dev, tmp, &acpi_wakeup_device_list,
  89                                  wakeup_list) {
  90                 if (device_can_wakeup(&dev->dev)) {
  91                         /* Button GPEs are supposed to be always enabled. */
  92                         acpi_enable_gpe(dev->wakeup.gpe_device,
  93                                         dev->wakeup.gpe_number);
  94                         device_set_wakeup_enable(&dev->dev, true);
  95                 }
  96         }
  97         mutex_unlock(&acpi_device_lock);
  98         return 0;
  99 }
 100
 101 /**
 102  * acpi_register_wakeup_handler - Register wakeup handler
 103  * @wake_irq: The IRQ through which the device may receive wakeups
 104  * @wakeup:   Wakeup-handler to call when the SCI has triggered a wakeup
 105  * @context:  Context to pass to the handler when calling it
 106  *
 107  * Drivers which may share an IRQ with the SCI can use this to register
 108  * a handler which returns true when the device they are managing wants
 109  * to trigger a wakeup.
 110  */
 111 int acpi_register_wakeup_handler(int wake_irq, bool (*wakeup)(void *context),
 112                                  void *context)
 113 {
 114         struct acpi_wakeup_handler *handler;
 115
 116         /*
 117          * If the device is not sharing its IRQ with the SCI, there is no
 118          * need to register the handler.
 119          */
 120         if (!acpi_sci_irq_valid() || wake_irq != acpi_sci_irq)
 121                 return 0;
 122
 123         handler = kmalloc(sizeof(*handler), GFP_KERNEL);
 124         if (!handler)
 125                 return -ENOMEM;
 126
 127         handler->wakeup = wakeup;
 128         handler->context = context;
 129
 130         mutex_lock(&acpi_wakeup_handler_mutex);
 131         list_add(&handler->list_node, &acpi_wakeup_handler_head);
 132         mutex_unlock(&acpi_wakeup_handler_mutex);
 133
 134         return 0;
 135 }
 136 EXPORT_SYMBOL_GPL(acpi_register_wakeup_handler);
 137
 138 /**
 139  * acpi_unregister_wakeup_handler - Unregister wakeup handler
 140  * @wakeup:   Wakeup-handler passed to acpi_register_wakeup_handler()
 141  * @context:  Context passed to acpi_register_wakeup_handler()
 142  */
 143 void acpi_unregister_wakeup_handler(bool (*wakeup)(void *context),
 144                                     void *context)
 145 {
 146         struct acpi_wakeup_handler *handler;
 147
 148         mutex_lock(&acpi_wakeup_handler_mutex);
 149         list_for_each_entry(handler, &acpi_wakeup_handler_head, list_node) {
 150                 if (handler->wakeup == wakeup && handler->context == context) {
 151                         list_del(&handler->list_node);
 152                         kfree(handler);
 153                         break;
 154                 }
 155         }
 156         mutex_unlock(&acpi_wakeup_handler_mutex);
 157 }
 158 EXPORT_SYMBOL_GPL(acpi_unregister_wakeup_handler);
 159
 160 bool acpi_check_wakeup_handlers(void)
 161 {
 162         struct acpi_wakeup_handler *handler;
 163
 164         /* No need to lock, nothing else is running when we're called. */
 165         list_for_each_entry(handler, &acpi_wakeup_handler_head, list_node) {
 166                 if (handler->wakeup(handler->context))
 167                         return true;
 168         }
 169
 170         return false;
 171 }