kernel/irq/pm.c

   1 /*
   2  * linux/kernel/irq/pm.c
   3  *
   4  * Copyright (C) 2009 Rafael J. Wysocki <rjw@sisk.pl>, Novell Inc.
   5  *
   6  * This file contains power management functions related to interrupts.
   7  */
   8
   9 #include <linux/irq.h>
  10 #include <linux/module.h>
  11 #include <linux/interrupt.h>
  12 #include <linux/suspend.h>
  13 #include <linux/syscore_ops.h>
  14
  15 #include "internals.h"
  16
  17 bool irq_pm_check_wakeup(struct irq_desc *desc)
  18 {
  19         if (irqd_is_wakeup_armed(&desc->irq_data)) {
  20                 irqd_clear(&desc->irq_data, IRQD_WAKEUP_ARMED);
  21                 desc->istate |= IRQS_SUSPENDED | IRQS_PENDING;
  22                 desc->depth++;
  23                 irq_disable(desc);
  24                 pm_system_wakeup();
  25                 return true;
  26         }
  27         return false;
  28 }
  29
  30 /*
  31  * Called from __setup_irq() with desc->lock held after @action has
  32  * been installed in the action chain.
  33  */
  34 void irq_pm_install_action(struct irq_desc *desc, struct irqaction *action)
  35 {
  36         desc->nr_actions++;
  37
  38         if (action->flags & IRQF_FORCE_RESUME)
  39                 desc->force_resume_depth++;
  40
  41         WARN_ON_ONCE(desc->force_resume_depth &&
  42                      desc->force_resume_depth != desc->nr_actions);
  43
  44         if (action->flags & IRQF_NO_SUSPEND)
  45                 desc->no_suspend_depth++;
  46
  47         WARN_ON_ONCE(desc->no_suspend_depth &&
  48                      desc->no_suspend_depth != desc->nr_actions);
  49 }
  50
  51 /*
  52  * Called from __free_irq() with desc->lock held after @action has
  53  * been removed from the action chain.
  54  */
  55 void irq_pm_remove_action(struct irq_desc *desc, struct irqaction *action)
  56 {
  57         desc->nr_actions--;
  58
  59         if (action->flags & IRQF_FORCE_RESUME)
  60                 desc->force_resume_depth--;
  61
  62         if (action->flags & IRQF_NO_SUSPEND)
  63                 desc->no_suspend_depth--;
  64 }
  65
  66 static bool suspend_device_irq(struct irq_desc *desc, int irq)
  67 {
  68         if (!desc->action || desc->no_suspend_depth)
  69                 return false;
  70
  71         if (irqd_is_wakeup_set(&desc->irq_data)) {
  72                 irqd_set(&desc->irq_data, IRQD_WAKEUP_ARMED);
  73                 /*
  74                  * We return true here to force the caller to issue
  75                  * synchronize_irq(). We need to make sure that the
  76                  * IRQD_WAKEUP_ARMED is visible before we return from
  77                  * suspend_device_irqs().
  78                  */
  79                 return true;
  80         }
  81
  82         desc->istate |= IRQS_SUSPENDED;
  83         __disable_irq(desc, irq);
  84
  85         /*
  86          * Hardware which has no wakeup source configuration facility
  87          * requires that the non wakeup interrupts are masked at the
  88          * chip level. The chip implementation indicates that with
  89          * IRQCHIP_MASK_ON_SUSPEND.
  90          */
  91         if (irq_desc_get_chip(desc)->flags & IRQCHIP_MASK_ON_SUSPEND)
  92                 mask_irq(desc);
  93         return true;
  94 }
  95
  96 /**
  97  * suspend_device_irqs - disable all currently enabled interrupt lines
  98  *
  99  * During system-wide suspend or hibernation device drivers need to be
 100  * prevented from receiving interrupts and this function is provided
 101  * for this purpose.
 102  *
 103  * So we disable all interrupts and mark them IRQS_SUSPENDED except
 104  * for those which are unused, those which are marked as not
 105  * suspendable via an interrupt request with the flag IRQF_NO_SUSPEND
 106  * set and those which are marked as active wakeup sources.
 107  *
 108  * The active wakeup sources are handled by the flow handler entry
 109  * code which checks for the IRQD_WAKEUP_ARMED flag, suspends the
 110  * interrupt and notifies the pm core about the wakeup.
 111  */
 112 void suspend_device_irqs(void)
 113 {
 114         struct irq_desc *desc;
 115         int irq;
 116
 117         for_each_irq_desc(irq, desc) {
 118                 unsigned long flags;
 119                 bool sync;
 120
 121                 raw_spin_lock_irqsave(&desc->lock, flags);
 122                 sync = suspend_device_irq(desc, irq);
 123                 raw_spin_unlock_irqrestore(&desc->lock, flags);
 124
 125                 if (sync)
 126                         synchronize_irq(irq);
 127         }
 128 }
 129 EXPORT_SYMBOL_GPL(suspend_device_irqs);
 130
 131 static void resume_irq(struct irq_desc *desc, int irq)
 132 {
 133         irqd_clear(&desc->irq_data, IRQD_WAKEUP_ARMED);
 134
 135         if (desc->istate & IRQS_SUSPENDED)
 136                 goto resume;
 137
 138         /* Force resume the interrupt? */
 139         if (!desc->force_resume_depth)
 140                 return;
 141
 142         /* Pretend that it got disabled ! */
 143         desc->depth++;
 144 resume:
 145         desc->istate &= ~IRQS_SUSPENDED;
 146         __enable_irq(desc, irq);
 147 }
 148
 149 static void resume_irqs(bool want_early)
 150 {
 151         struct irq_desc *desc;
 152         int irq;
 153
 154         for_each_irq_desc(irq, desc) {
 155                 unsigned long flags;
 156                 bool is_early = desc->action &&
 157                         desc->action->flags & IRQF_EARLY_RESUME;
 158
 159                 if (!is_early && want_early)
 160                         continue;
 161
 162                 raw_spin_lock_irqsave(&desc->lock, flags);
 163                 resume_irq(desc, irq);
 164                 raw_spin_unlock_irqrestore(&desc->lock, flags);
 165         }
 166 }
 167
 168 /**
 169  * irq_pm_syscore_ops - enable interrupt lines early
 170  *
 171  * Enable all interrupt lines with %IRQF_EARLY_RESUME set.
 172  */
 173 static void irq_pm_syscore_resume(void)
 174 {
 175         resume_irqs(true);
 176 }
 177
 178 static struct syscore_ops irq_pm_syscore_ops = {
 179         .resume         = irq_pm_syscore_resume,
 180 };
 181
 182 static int __init irq_pm_init_ops(void)
 183 {
 184         register_syscore_ops(&irq_pm_syscore_ops);
 185         return 0;
 186 }
 187
 188 device_initcall(irq_pm_init_ops);
 189
 190 /**
 191  * resume_device_irqs - enable interrupt lines disabled by suspend_device_irqs()
 192  *
 193  * Enable all non-%IRQF_EARLY_RESUME interrupt lines previously
 194  * disabled by suspend_device_irqs() that have the IRQS_SUSPENDED flag
 195  * set as well as those with %IRQF_FORCE_RESUME.
 196  */
 197 void resume_device_irqs(void)
 198 {
 199         resume_irqs(false);
 200 }
 201 EXPORT_SYMBOL_GPL(resume_device_irqs);