kernel/pm.c

   1 /*
   2  *  pm.c - Power management interface
   3  *
   4  *  Copyright (C) 2000 Andrew Henroid
   5  *
   6  *  This program is free software; you can redistribute it and/or modify
   7  *  it under the terms of the GNU General Public License as published by
   8  *  the Free Software Foundation; either version 2 of the License, or
   9  *  (at your option) any later version.
  10  *
  11  *  This program is distributed in the hope that it will be useful,
  12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  *  GNU General Public License for more details.
  15  *
  16  *  You should have received a copy of the GNU General Public License
  17  *  along with this program; if not, write to the Free Software
  18  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  */
  20
  21 #include <linux/module.h>
  22 #include <linux/spinlock.h>
  23 #include <linux/slab.h>
  24 #include <linux/pm.h>
  25
  26 int pm_active;
  27
  28 static spinlock_t pm_devs_lock = SPIN_LOCK_UNLOCKED;
  29 static LIST_HEAD(pm_devs);
  30
  31 /**
  32  *      pm_register - register a device with power management
  33  *      @type: device type
  34  *      @id: device ID
  35  *      @callback: callback function
  36  *
  37  *      Add a device to the list of devices that wish to be notified about
  38  *      power management events. A &pm_dev structure is returned on success,
  39  *      on failure the return is %NULL.
  40  */
  41
  42 struct pm_dev *pm_register(pm_dev_t type,
  43                            unsigned long id,
  44                            pm_callback callback)
  45 {
  46         struct pm_dev *dev = kmalloc(sizeof(struct pm_dev), GFP_KERNEL);
  47         if (dev) {
  48                 unsigned long flags;
  49
  50                 memset(dev, 0, sizeof(*dev));
  51                 dev->type = type;
  52                 dev->id = id;
  53                 dev->callback = callback;
  54
  55                 spin_lock_irqsave(&pm_devs_lock, flags);
  56                 list_add(&dev->entry, &pm_devs);
  57                 spin_unlock_irqrestore(&pm_devs_lock, flags);
  58         }
  59         return dev;
  60 }
  61
  62 /**
  63  *      pm_unregister -  unregister a device with power management
  64  *      @dev: device to unregister
  65  *
  66  *      Remove a device from the power management notification lists. The
  67  *      dev passed must be a handle previously returned by pm_register.
  68  */
  69
  70 void pm_unregister(struct pm_dev *dev)
  71 {
  72         if (dev) {
  73                 unsigned long flags;
  74
  75                 spin_lock_irqsave(&pm_devs_lock, flags);
  76                 list_del(&dev->entry);
  77                 spin_unlock_irqrestore(&pm_devs_lock, flags);
  78
  79                 kfree(dev);
  80         }
  81 }
  82
  83 /**
  84  *      pm_unregister_all - unregister all devices with matching callback
  85  *      @callback: callback function pointer
  86  *
  87  *      Unregister every device that would call the callback passed. This
  88  *      is primarily meant as a helper function for loadable modules. It
  89  *      enables a module to give up all its managed devices without keeping
  90  *      its own private list.
  91  */
  92
  93 void pm_unregister_all(pm_callback callback)
  94 {
  95         struct list_head *entry;
  96
  97         if (!callback)
  98                 return;
  99
 100         entry = pm_devs.next;
 101         while (entry != &pm_devs) {
 102                 struct pm_dev *dev = list_entry(entry, struct pm_dev, entry);
 103                 entry = entry->next;
 104                 if (dev->callback == callback)
 105                         pm_unregister(dev);
 106         }
 107 }
 108
 109 /**
 110  *      pm_send - send request to a single device
 111  *      @dev: device to send to
 112  *      @rqst: power management request
 113  *      @data: data for the callback
 114  *
 115  *      Issue a power management request to a given device. The
 116  *      %PM_SUSPEND and %PM_RESUME events are handled specially. The
 117  *      data field must hold the intended next state. No call is made
 118  *      if the state matches.
 119  *
 120  *      BUGS: what stops two power management requests occuring in parallel
 121  *      and conflicting.
 122  */
 123
 124 int pm_send(struct pm_dev *dev, pm_request_t rqst, void *data)
 125 {
 126         int status = 0;
 127         int prev_state, next_state;
 128         switch (rqst) {
 129         case PM_SUSPEND:
 130         case PM_RESUME:
 131                 prev_state = dev->state;
 132                 next_state = (int) data;
 133                 if (prev_state != next_state) {
 134                         if (dev->callback)
 135                                 status = (*dev->callback)(dev, rqst, data);
 136                         if (!status) {
 137                                 dev->state = next_state;
 138                                 dev->prev_state = prev_state;
 139                         }
 140                 }
 141                 else {
 142                         dev->prev_state = prev_state;
 143                 }
 144                 break;
 145         default:
 146                 if (dev->callback)
 147                         status = (*dev->callback)(dev, rqst, data);
 148                 break;
 149         }
 150         return status;
 151 }
 152
 153 /*
 154  * Undo incomplete request
 155  */
 156 static void pm_undo_all(struct pm_dev *last)
 157 {
 158         struct list_head *entry = last->entry.prev;
 159         while (entry != &pm_devs) {
 160                 struct pm_dev *dev = list_entry(entry, struct pm_dev, entry);
 161                 if (dev->state != dev->prev_state) {
 162                         /* previous state was zero (running) resume or
 163                          * previous state was non-zero (suspended) suspend
 164                          */
 165                         pm_request_t undo = (dev->prev_state
 166                                              ? PM_SUSPEND:PM_RESUME);
 167                         pm_send(dev, undo, (void*) dev->prev_state);
 168                 }
 169                 entry = entry->prev;
 170         }
 171 }
 172
 173 /**
 174  *      pm_send_all - send request to all managed devices
 175  *      @rqst: power management request
 176  *      @data: data for the callback
 177  *
 178  *      Issue a power management request to a all devices. The
 179  *      %PM_SUSPEND events are handled specially. Any device is
 180  *      permitted to fail a suspend by returning a non zero (error)
 181  *      value from its callback function. If any device vetoes a
 182  *      suspend request then all other devices that have suspended
 183  *      during the processing of this request are restored to their
 184  *      previous state.
 185  *
 186  *      Zero is returned on success. If a suspend fails then the status
 187  *      from the device that vetoes the suspend is returned.
 188  *
 189  *      BUGS: what stops two power management requests occuring in parallel
 190  *      and conflicting.
 191  */
 192
 193 int pm_send_all(pm_request_t rqst, void *data)
 194 {
 195         struct list_head *entry = pm_devs.next;
 196         while (entry != &pm_devs) {
 197                 struct pm_dev *dev = list_entry(entry, struct pm_dev, entry);
 198                 if (dev->callback) {
 199                         int status = pm_send(dev, rqst, data);
 200                         if (status) {
 201                                 /* return devices to previous state on
 202                                  * failed suspend request
 203                                  */
 204                                 if (rqst == PM_SUSPEND)
 205                                         pm_undo_all(dev);
 206                                 return status;
 207                         }
 208                 }
 209                 entry = entry->next;
 210         }
 211         return 0;
 212 }
 213
 214 /**
 215  *      pm_find  - find a device
 216  *      @type: type of device
 217  *      @from: where to start looking
 218  *
 219  *      Scan the power management list for devices of a specific type. The
 220  *      return value for a matching device may be passed to further calls
 221  *      to this function to find further matches. A %NULL indicates the end
 222  *      of the list.
 223  *
 224  *      To search from the beginning pass %NULL as the @from value.
 225  */
 226
 227 struct pm_dev *pm_find(pm_dev_t type, struct pm_dev *from)
 228 {
 229         struct list_head *entry = from ? from->entry.next:pm_devs.next;
 230         while (entry != &pm_devs) {
 231                 struct pm_dev *dev = list_entry(entry, struct pm_dev, entry);
 232                 if (type == PM_UNKNOWN_DEV || dev->type == type)
 233                         return dev;
 234                 entry = entry->next;
 235         }
 236         return 0;
 237 }
 238
 239 EXPORT_SYMBOL(pm_register);
 240 EXPORT_SYMBOL(pm_unregister);
 241 EXPORT_SYMBOL(pm_unregister_all);
 242 EXPORT_SYMBOL(pm_send);
 243 EXPORT_SYMBOL(pm_send_all);
 244 EXPORT_SYMBOL(pm_find);
 245 EXPORT_SYMBOL(pm_active);