PM / Runtime: Allow _put_sync() from interrupts-disabled context
[linux-2.6.git] / drivers / base / power / runtime.c
1 /*
2  * drivers/base/power/runtime.c - Helper functions for device runtime PM
3  *
4  * Copyright (c) 2009 Rafael J. Wysocki <rjw@sisk.pl>, Novell Inc.
5  * Copyright (C) 2010 Alan Stern <stern@rowland.harvard.edu>
6  *
7  * This file is released under the GPLv2.
8  */
9
10 #include <linux/sched.h>
11 #include <linux/pm_runtime.h>
12 #include "power.h"
13
14 static int rpm_resume(struct device *dev, int rpmflags);
15 static int rpm_suspend(struct device *dev, int rpmflags);
16
17 /**
18  * update_pm_runtime_accounting - Update the time accounting of power states
19  * @dev: Device to update the accounting for
20  *
21  * In order to be able to have time accounting of the various power states
22  * (as used by programs such as PowerTOP to show the effectiveness of runtime
23  * PM), we need to track the time spent in each state.
24  * update_pm_runtime_accounting must be called each time before the
25  * runtime_status field is updated, to account the time in the old state
26  * correctly.
27  */
28 void update_pm_runtime_accounting(struct device *dev)
29 {
30         unsigned long now = jiffies;
31         int delta;
32
33         delta = now - dev->power.accounting_timestamp;
34
35         if (delta < 0)
36                 delta = 0;
37
38         dev->power.accounting_timestamp = now;
39
40         if (dev->power.disable_depth > 0)
41                 return;
42
43         if (dev->power.runtime_status == RPM_SUSPENDED)
44                 dev->power.suspended_jiffies += delta;
45         else
46                 dev->power.active_jiffies += delta;
47 }
48
49 static void __update_runtime_status(struct device *dev, enum rpm_status status)
50 {
51         update_pm_runtime_accounting(dev);
52         dev->power.runtime_status = status;
53 }
54
55 /**
56  * pm_runtime_deactivate_timer - Deactivate given device's suspend timer.
57  * @dev: Device to handle.
58  */
59 static void pm_runtime_deactivate_timer(struct device *dev)
60 {
61         if (dev->power.timer_expires > 0) {
62                 del_timer(&dev->power.suspend_timer);
63                 dev->power.timer_expires = 0;
64         }
65 }
66
67 /**
68  * pm_runtime_cancel_pending - Deactivate suspend timer and cancel requests.
69  * @dev: Device to handle.
70  */
71 static void pm_runtime_cancel_pending(struct device *dev)
72 {
73         pm_runtime_deactivate_timer(dev);
74         /*
75          * In case there's a request pending, make sure its work function will
76          * return without doing anything.
77          */
78         dev->power.request = RPM_REQ_NONE;
79 }
80
81 /*
82  * pm_runtime_autosuspend_expiration - Get a device's autosuspend-delay expiration time.
83  * @dev: Device to handle.
84  *
85  * Compute the autosuspend-delay expiration time based on the device's
86  * power.last_busy time.  If the delay has already expired or is disabled
87  * (negative) or the power.use_autosuspend flag isn't set, return 0.
88  * Otherwise return the expiration time in jiffies (adjusted to be nonzero).
89  *
90  * This function may be called either with or without dev->power.lock held.
91  * Either way it can be racy, since power.last_busy may be updated at any time.
92  */
93 unsigned long pm_runtime_autosuspend_expiration(struct device *dev)
94 {
95         int autosuspend_delay;
96         long elapsed;
97         unsigned long last_busy;
98         unsigned long expires = 0;
99
100         if (!dev->power.use_autosuspend)
101                 goto out;
102
103         autosuspend_delay = ACCESS_ONCE(dev->power.autosuspend_delay);
104         if (autosuspend_delay < 0)
105                 goto out;
106
107         last_busy = ACCESS_ONCE(dev->power.last_busy);
108         elapsed = jiffies - last_busy;
109         if (elapsed < 0)
110                 goto out;       /* jiffies has wrapped around. */
111
112         /*
113          * If the autosuspend_delay is >= 1 second, align the timer by rounding
114          * up to the nearest second.
115          */
116         expires = last_busy + msecs_to_jiffies(autosuspend_delay);
117         if (autosuspend_delay >= 1000)
118                 expires = round_jiffies(expires);
119         expires += !expires;
120         if (elapsed >= expires - last_busy)
121                 expires = 0;    /* Already expired. */
122
123  out:
124         return expires;
125 }
126 EXPORT_SYMBOL_GPL(pm_runtime_autosuspend_expiration);
127
128 /**
129  * rpm_check_suspend_allowed - Test whether a device may be suspended.
130  * @dev: Device to test.
131  */
132 static int rpm_check_suspend_allowed(struct device *dev)
133 {
134         int retval = 0;
135
136         if (dev->power.runtime_error)
137                 retval = -EINVAL;
138         else if (dev->power.disable_depth > 0)
139                 retval = -EACCES;
140         else if (atomic_read(&dev->power.usage_count) > 0)
141                 retval = -EAGAIN;
142         else if (!pm_children_suspended(dev))
143                 retval = -EBUSY;
144
145         /* Pending resume requests take precedence over suspends. */
146         else if ((dev->power.deferred_resume
147                         && dev->power.runtime_status == RPM_SUSPENDING)
148             || (dev->power.request_pending
149                         && dev->power.request == RPM_REQ_RESUME))
150                 retval = -EAGAIN;
151         else if (dev->power.runtime_status == RPM_SUSPENDED)
152                 retval = 1;
153
154         return retval;
155 }
156
157 /**
158  * rpm_idle - Notify device bus type if the device can be suspended.
159  * @dev: Device to notify the bus type about.
160  * @rpmflags: Flag bits.
161  *
162  * Check if the device's runtime PM status allows it to be suspended.  If
163  * another idle notification has been started earlier, return immediately.  If
164  * the RPM_ASYNC flag is set then queue an idle-notification request; otherwise
165  * run the ->runtime_idle() callback directly.
166  *
167  * This function must be called under dev->power.lock with interrupts disabled.
168  */
169 static int rpm_idle(struct device *dev, int rpmflags)
170 {
171         int (*callback)(struct device *);
172         int retval;
173
174         retval = rpm_check_suspend_allowed(dev);
175         if (retval < 0)
176                 ;       /* Conditions are wrong. */
177
178         /* Idle notifications are allowed only in the RPM_ACTIVE state. */
179         else if (dev->power.runtime_status != RPM_ACTIVE)
180                 retval = -EAGAIN;
181
182         /*
183          * Any pending request other than an idle notification takes
184          * precedence over us, except that the timer may be running.
185          */
186         else if (dev->power.request_pending &&
187             dev->power.request > RPM_REQ_IDLE)
188                 retval = -EAGAIN;
189
190         /* Act as though RPM_NOWAIT is always set. */
191         else if (dev->power.idle_notification)
192                 retval = -EINPROGRESS;
193         if (retval)
194                 goto out;
195
196         /* Pending requests need to be canceled. */
197         dev->power.request = RPM_REQ_NONE;
198
199         if (dev->power.no_callbacks) {
200                 /* Assume ->runtime_idle() callback would have suspended. */
201                 retval = rpm_suspend(dev, rpmflags);
202                 goto out;
203         }
204
205         /* Carry out an asynchronous or a synchronous idle notification. */
206         if (rpmflags & RPM_ASYNC) {
207                 dev->power.request = RPM_REQ_IDLE;
208                 if (!dev->power.request_pending) {
209                         dev->power.request_pending = true;
210                         queue_work(pm_wq, &dev->power.work);
211                 }
212                 goto out;
213         }
214
215         dev->power.idle_notification = true;
216
217         if (dev->pm_domain)
218                 callback = dev->pm_domain->ops.runtime_idle;
219         else if (dev->type && dev->type->pm)
220                 callback = dev->type->pm->runtime_idle;
221         else if (dev->class && dev->class->pm)
222                 callback = dev->class->pm->runtime_idle;
223         else if (dev->bus && dev->bus->pm)
224                 callback = dev->bus->pm->runtime_idle;
225         else
226                 callback = NULL;
227
228         if (callback) {
229                 if (dev->power.irq_safe)
230                         spin_unlock(&dev->power.lock);
231                 else
232                         spin_unlock_irq(&dev->power.lock);
233
234                 callback(dev);
235
236                 if (dev->power.irq_safe)
237                         spin_lock(&dev->power.lock);
238                 else
239                         spin_lock_irq(&dev->power.lock);
240         }
241
242         dev->power.idle_notification = false;
243         wake_up_all(&dev->power.wait_queue);
244
245  out:
246         return retval;
247 }
248
249 /**
250  * rpm_callback - Run a given runtime PM callback for a given device.
251  * @cb: Runtime PM callback to run.
252  * @dev: Device to run the callback for.
253  */
254 static int rpm_callback(int (*cb)(struct device *), struct device *dev)
255         __releases(&dev->power.lock) __acquires(&dev->power.lock)
256 {
257         int retval;
258
259         if (!cb)
260                 return -ENOSYS;
261
262         if (dev->power.irq_safe) {
263                 retval = cb(dev);
264         } else {
265                 spin_unlock_irq(&dev->power.lock);
266
267                 retval = cb(dev);
268
269                 spin_lock_irq(&dev->power.lock);
270         }
271         dev->power.runtime_error = retval;
272         return retval != -EACCES ? retval : -EIO;
273 }
274
275 /**
276  * rpm_suspend - Carry out runtime suspend of given device.
277  * @dev: Device to suspend.
278  * @rpmflags: Flag bits.
279  *
280  * Check if the device's runtime PM status allows it to be suspended.  If
281  * another suspend has been started earlier, either return immediately or wait
282  * for it to finish, depending on the RPM_NOWAIT and RPM_ASYNC flags.  Cancel a
283  * pending idle notification.  If the RPM_ASYNC flag is set then queue a
284  * suspend request; otherwise run the ->runtime_suspend() callback directly.
285  * If a deferred resume was requested while the callback was running then carry
286  * it out; otherwise send an idle notification for the device (if the suspend
287  * failed) or for its parent (if the suspend succeeded).
288  *
289  * This function must be called under dev->power.lock with interrupts disabled.
290  */
291 static int rpm_suspend(struct device *dev, int rpmflags)
292         __releases(&dev->power.lock) __acquires(&dev->power.lock)
293 {
294         int (*callback)(struct device *);
295         struct device *parent = NULL;
296         int retval;
297
298         dev_dbg(dev, "%s flags 0x%x\n", __func__, rpmflags);
299
300  repeat:
301         retval = rpm_check_suspend_allowed(dev);
302
303         if (retval < 0)
304                 ;       /* Conditions are wrong. */
305
306         /* Synchronous suspends are not allowed in the RPM_RESUMING state. */
307         else if (dev->power.runtime_status == RPM_RESUMING &&
308             !(rpmflags & RPM_ASYNC))
309                 retval = -EAGAIN;
310         if (retval)
311                 goto out;
312
313         /* If the autosuspend_delay time hasn't expired yet, reschedule. */
314         if ((rpmflags & RPM_AUTO)
315             && dev->power.runtime_status != RPM_SUSPENDING) {
316                 unsigned long expires = pm_runtime_autosuspend_expiration(dev);
317
318                 if (expires != 0) {
319                         /* Pending requests need to be canceled. */
320                         dev->power.request = RPM_REQ_NONE;
321
322                         /*
323                          * Optimization: If the timer is already running and is
324                          * set to expire at or before the autosuspend delay,
325                          * avoid the overhead of resetting it.  Just let it
326                          * expire; pm_suspend_timer_fn() will take care of the
327                          * rest.
328                          */
329                         if (!(dev->power.timer_expires && time_before_eq(
330                             dev->power.timer_expires, expires))) {
331                                 dev->power.timer_expires = expires;
332                                 mod_timer(&dev->power.suspend_timer, expires);
333                         }
334                         dev->power.timer_autosuspends = 1;
335                         goto out;
336                 }
337         }
338
339         /* Other scheduled or pending requests need to be canceled. */
340         pm_runtime_cancel_pending(dev);
341
342         if (dev->power.runtime_status == RPM_SUSPENDING) {
343                 DEFINE_WAIT(wait);
344
345                 if (rpmflags & (RPM_ASYNC | RPM_NOWAIT)) {
346                         retval = -EINPROGRESS;
347                         goto out;
348                 }
349
350                 /* Wait for the other suspend running in parallel with us. */
351                 for (;;) {
352                         prepare_to_wait(&dev->power.wait_queue, &wait,
353                                         TASK_UNINTERRUPTIBLE);
354                         if (dev->power.runtime_status != RPM_SUSPENDING)
355                                 break;
356
357                         spin_unlock_irq(&dev->power.lock);
358
359                         schedule();
360
361                         spin_lock_irq(&dev->power.lock);
362                 }
363                 finish_wait(&dev->power.wait_queue, &wait);
364                 goto repeat;
365         }
366
367         dev->power.deferred_resume = false;
368         if (dev->power.no_callbacks)
369                 goto no_callback;       /* Assume success. */
370
371         /* Carry out an asynchronous or a synchronous suspend. */
372         if (rpmflags & RPM_ASYNC) {
373                 dev->power.request = (rpmflags & RPM_AUTO) ?
374                     RPM_REQ_AUTOSUSPEND : RPM_REQ_SUSPEND;
375                 if (!dev->power.request_pending) {
376                         dev->power.request_pending = true;
377                         queue_work(pm_wq, &dev->power.work);
378                 }
379                 goto out;
380         }
381
382         __update_runtime_status(dev, RPM_SUSPENDING);
383
384         if (dev->pm_domain)
385                 callback = dev->pm_domain->ops.runtime_suspend;
386         else if (dev->type && dev->type->pm)
387                 callback = dev->type->pm->runtime_suspend;
388         else if (dev->class && dev->class->pm)
389                 callback = dev->class->pm->runtime_suspend;
390         else if (dev->bus && dev->bus->pm)
391                 callback = dev->bus->pm->runtime_suspend;
392         else
393                 callback = NULL;
394
395         retval = rpm_callback(callback, dev);
396         if (retval) {
397                 __update_runtime_status(dev, RPM_ACTIVE);
398                 dev->power.deferred_resume = false;
399                 if (retval == -EAGAIN || retval == -EBUSY)
400                         dev->power.runtime_error = 0;
401                 else
402                         pm_runtime_cancel_pending(dev);
403         } else {
404  no_callback:
405                 __update_runtime_status(dev, RPM_SUSPENDED);
406                 pm_runtime_deactivate_timer(dev);
407
408                 if (dev->parent) {
409                         parent = dev->parent;
410                         atomic_add_unless(&parent->power.child_count, -1, 0);
411                 }
412         }
413         wake_up_all(&dev->power.wait_queue);
414
415         if (dev->power.deferred_resume) {
416                 rpm_resume(dev, 0);
417                 retval = -EAGAIN;
418                 goto out;
419         }
420
421         /* Maybe the parent is now able to suspend. */
422         if (parent && !parent->power.ignore_children && !dev->power.irq_safe) {
423                 spin_unlock(&dev->power.lock);
424
425                 spin_lock(&parent->power.lock);
426                 rpm_idle(parent, RPM_ASYNC);
427                 spin_unlock(&parent->power.lock);
428
429                 spin_lock(&dev->power.lock);
430         }
431
432  out:
433         dev_dbg(dev, "%s returns %d\n", __func__, retval);
434
435         return retval;
436 }
437
438 /**
439  * rpm_resume - Carry out runtime resume of given device.
440  * @dev: Device to resume.
441  * @rpmflags: Flag bits.
442  *
443  * Check if the device's runtime PM status allows it to be resumed.  Cancel
444  * any scheduled or pending requests.  If another resume has been started
445  * earlier, either return immediately or wait for it to finish, depending on the
446  * RPM_NOWAIT and RPM_ASYNC flags.  Similarly, if there's a suspend running in
447  * parallel with this function, either tell the other process to resume after
448  * suspending (deferred_resume) or wait for it to finish.  If the RPM_ASYNC
449  * flag is set then queue a resume request; otherwise run the
450  * ->runtime_resume() callback directly.  Queue an idle notification for the
451  * device if the resume succeeded.
452  *
453  * This function must be called under dev->power.lock with interrupts disabled.
454  */
455 static int rpm_resume(struct device *dev, int rpmflags)
456         __releases(&dev->power.lock) __acquires(&dev->power.lock)
457 {
458         int (*callback)(struct device *);
459         struct device *parent = NULL;
460         int retval = 0;
461
462         dev_dbg(dev, "%s flags 0x%x\n", __func__, rpmflags);
463
464  repeat:
465         if (dev->power.runtime_error)
466                 retval = -EINVAL;
467         else if (dev->power.disable_depth > 0)
468                 retval = -EACCES;
469         if (retval)
470                 goto out;
471
472         /*
473          * Other scheduled or pending requests need to be canceled.  Small
474          * optimization: If an autosuspend timer is running, leave it running
475          * rather than cancelling it now only to restart it again in the near
476          * future.
477          */
478         dev->power.request = RPM_REQ_NONE;
479         if (!dev->power.timer_autosuspends)
480                 pm_runtime_deactivate_timer(dev);
481
482         if (dev->power.runtime_status == RPM_ACTIVE) {
483                 retval = 1;
484                 goto out;
485         }
486
487         if (dev->power.runtime_status == RPM_RESUMING
488             || dev->power.runtime_status == RPM_SUSPENDING) {
489                 DEFINE_WAIT(wait);
490
491                 if (rpmflags & (RPM_ASYNC | RPM_NOWAIT)) {
492                         if (dev->power.runtime_status == RPM_SUSPENDING)
493                                 dev->power.deferred_resume = true;
494                         else
495                                 retval = -EINPROGRESS;
496                         goto out;
497                 }
498
499                 /* Wait for the operation carried out in parallel with us. */
500                 for (;;) {
501                         prepare_to_wait(&dev->power.wait_queue, &wait,
502                                         TASK_UNINTERRUPTIBLE);
503                         if (dev->power.runtime_status != RPM_RESUMING
504                             && dev->power.runtime_status != RPM_SUSPENDING)
505                                 break;
506
507                         spin_unlock_irq(&dev->power.lock);
508
509                         schedule();
510
511                         spin_lock_irq(&dev->power.lock);
512                 }
513                 finish_wait(&dev->power.wait_queue, &wait);
514                 goto repeat;
515         }
516
517         /*
518          * See if we can skip waking up the parent.  This is safe only if
519          * power.no_callbacks is set, because otherwise we don't know whether
520          * the resume will actually succeed.
521          */
522         if (dev->power.no_callbacks && !parent && dev->parent) {
523                 spin_lock_nested(&dev->parent->power.lock, SINGLE_DEPTH_NESTING);
524                 if (dev->parent->power.disable_depth > 0
525                     || dev->parent->power.ignore_children
526                     || dev->parent->power.runtime_status == RPM_ACTIVE) {
527                         atomic_inc(&dev->parent->power.child_count);
528                         spin_unlock(&dev->parent->power.lock);
529                         goto no_callback;       /* Assume success. */
530                 }
531                 spin_unlock(&dev->parent->power.lock);
532         }
533
534         /* Carry out an asynchronous or a synchronous resume. */
535         if (rpmflags & RPM_ASYNC) {
536                 dev->power.request = RPM_REQ_RESUME;
537                 if (!dev->power.request_pending) {
538                         dev->power.request_pending = true;
539                         queue_work(pm_wq, &dev->power.work);
540                 }
541                 retval = 0;
542                 goto out;
543         }
544
545         if (!parent && dev->parent) {
546                 /*
547                  * Increment the parent's usage counter and resume it if
548                  * necessary.  Not needed if dev is irq-safe; then the
549                  * parent is permanently resumed.
550                  */
551                 parent = dev->parent;
552                 if (dev->power.irq_safe)
553                         goto skip_parent;
554                 spin_unlock(&dev->power.lock);
555
556                 pm_runtime_get_noresume(parent);
557
558                 spin_lock(&parent->power.lock);
559                 /*
560                  * We can resume if the parent's runtime PM is disabled or it
561                  * is set to ignore children.
562                  */
563                 if (!parent->power.disable_depth
564                     && !parent->power.ignore_children) {
565                         rpm_resume(parent, 0);
566                         if (parent->power.runtime_status != RPM_ACTIVE)
567                                 retval = -EBUSY;
568                 }
569                 spin_unlock(&parent->power.lock);
570
571                 spin_lock(&dev->power.lock);
572                 if (retval)
573                         goto out;
574                 goto repeat;
575         }
576  skip_parent:
577
578         if (dev->power.no_callbacks)
579                 goto no_callback;       /* Assume success. */
580
581         __update_runtime_status(dev, RPM_RESUMING);
582
583         if (dev->pm_domain)
584                 callback = dev->pm_domain->ops.runtime_resume;
585         else if (dev->type && dev->type->pm)
586                 callback = dev->type->pm->runtime_resume;
587         else if (dev->class && dev->class->pm)
588                 callback = dev->class->pm->runtime_resume;
589         else if (dev->bus && dev->bus->pm)
590                 callback = dev->bus->pm->runtime_resume;
591         else
592                 callback = NULL;
593
594         retval = rpm_callback(callback, dev);
595         if (retval) {
596                 __update_runtime_status(dev, RPM_SUSPENDED);
597                 pm_runtime_cancel_pending(dev);
598         } else {
599  no_callback:
600                 __update_runtime_status(dev, RPM_ACTIVE);
601                 if (parent)
602                         atomic_inc(&parent->power.child_count);
603         }
604         wake_up_all(&dev->power.wait_queue);
605
606         if (!retval)
607                 rpm_idle(dev, RPM_ASYNC);
608
609  out:
610         if (parent && !dev->power.irq_safe) {
611                 spin_unlock_irq(&dev->power.lock);
612
613                 pm_runtime_put(parent);
614
615                 spin_lock_irq(&dev->power.lock);
616         }
617
618         dev_dbg(dev, "%s returns %d\n", __func__, retval);
619
620         return retval;
621 }
622
623 /**
624  * pm_runtime_work - Universal runtime PM work function.
625  * @work: Work structure used for scheduling the execution of this function.
626  *
627  * Use @work to get the device object the work is to be done for, determine what
628  * is to be done and execute the appropriate runtime PM function.
629  */
630 static void pm_runtime_work(struct work_struct *work)
631 {
632         struct device *dev = container_of(work, struct device, power.work);
633         enum rpm_request req;
634
635         spin_lock_irq(&dev->power.lock);
636
637         if (!dev->power.request_pending)
638                 goto out;
639
640         req = dev->power.request;
641         dev->power.request = RPM_REQ_NONE;
642         dev->power.request_pending = false;
643
644         switch (req) {
645         case RPM_REQ_NONE:
646                 break;
647         case RPM_REQ_IDLE:
648                 rpm_idle(dev, RPM_NOWAIT);
649                 break;
650         case RPM_REQ_SUSPEND:
651                 rpm_suspend(dev, RPM_NOWAIT);
652                 break;
653         case RPM_REQ_AUTOSUSPEND:
654                 rpm_suspend(dev, RPM_NOWAIT | RPM_AUTO);
655                 break;
656         case RPM_REQ_RESUME:
657                 rpm_resume(dev, RPM_NOWAIT);
658                 break;
659         }
660
661  out:
662         spin_unlock_irq(&dev->power.lock);
663 }
664
665 /**
666  * pm_suspend_timer_fn - Timer function for pm_schedule_suspend().
667  * @data: Device pointer passed by pm_schedule_suspend().
668  *
669  * Check if the time is right and queue a suspend request.
670  */
671 static void pm_suspend_timer_fn(unsigned long data)
672 {
673         struct device *dev = (struct device *)data;
674         unsigned long flags;
675         unsigned long expires;
676
677         spin_lock_irqsave(&dev->power.lock, flags);
678
679         expires = dev->power.timer_expires;
680         /* If 'expire' is after 'jiffies' we've been called too early. */
681         if (expires > 0 && !time_after(expires, jiffies)) {
682                 dev->power.timer_expires = 0;
683                 rpm_suspend(dev, dev->power.timer_autosuspends ?
684                     (RPM_ASYNC | RPM_AUTO) : RPM_ASYNC);
685         }
686
687         spin_unlock_irqrestore(&dev->power.lock, flags);
688 }
689
690 /**
691  * pm_schedule_suspend - Set up a timer to submit a suspend request in future.
692  * @dev: Device to suspend.
693  * @delay: Time to wait before submitting a suspend request, in milliseconds.
694  */
695 int pm_schedule_suspend(struct device *dev, unsigned int delay)
696 {
697         unsigned long flags;
698         int retval;
699
700         spin_lock_irqsave(&dev->power.lock, flags);
701
702         if (!delay) {
703                 retval = rpm_suspend(dev, RPM_ASYNC);
704                 goto out;
705         }
706
707         retval = rpm_check_suspend_allowed(dev);
708         if (retval)
709                 goto out;
710
711         /* Other scheduled or pending requests need to be canceled. */
712         pm_runtime_cancel_pending(dev);
713
714         dev->power.timer_expires = jiffies + msecs_to_jiffies(delay);
715         dev->power.timer_expires += !dev->power.timer_expires;
716         dev->power.timer_autosuspends = 0;
717         mod_timer(&dev->power.suspend_timer, dev->power.timer_expires);
718
719  out:
720         spin_unlock_irqrestore(&dev->power.lock, flags);
721
722         return retval;
723 }
724 EXPORT_SYMBOL_GPL(pm_schedule_suspend);
725
726 /**
727  * __pm_runtime_idle - Entry point for runtime idle operations.
728  * @dev: Device to send idle notification for.
729  * @rpmflags: Flag bits.
730  *
731  * If the RPM_GET_PUT flag is set, decrement the device's usage count and
732  * return immediately if it is larger than zero.  Then carry out an idle
733  * notification, either synchronous or asynchronous.
734  *
735  * This routine may be called in atomic context if the RPM_ASYNC flag is set.
736  */
737 int __pm_runtime_idle(struct device *dev, int rpmflags)
738 {
739         unsigned long flags;
740         int retval;
741
742         if (rpmflags & RPM_GET_PUT) {
743                 if (!atomic_dec_and_test(&dev->power.usage_count))
744                         return 0;
745         }
746
747         spin_lock_irqsave(&dev->power.lock, flags);
748         retval = rpm_idle(dev, rpmflags);
749         spin_unlock_irqrestore(&dev->power.lock, flags);
750
751         return retval;
752 }
753 EXPORT_SYMBOL_GPL(__pm_runtime_idle);
754
755 /**
756  * __pm_runtime_suspend - Entry point for runtime put/suspend operations.
757  * @dev: Device to suspend.
758  * @rpmflags: Flag bits.
759  *
760  * If the RPM_GET_PUT flag is set, decrement the device's usage count and
761  * return immediately if it is larger than zero.  Then carry out a suspend,
762  * either synchronous or asynchronous.
763  *
764  * This routine may be called in atomic context if the RPM_ASYNC flag is set.
765  */
766 int __pm_runtime_suspend(struct device *dev, int rpmflags)
767 {
768         unsigned long flags;
769         int retval;
770
771         if (rpmflags & RPM_GET_PUT) {
772                 if (!atomic_dec_and_test(&dev->power.usage_count))
773                         return 0;
774         }
775
776         spin_lock_irqsave(&dev->power.lock, flags);
777         retval = rpm_suspend(dev, rpmflags);
778         spin_unlock_irqrestore(&dev->power.lock, flags);
779
780         return retval;
781 }
782 EXPORT_SYMBOL_GPL(__pm_runtime_suspend);
783
784 /**
785  * __pm_runtime_resume - Entry point for runtime resume operations.
786  * @dev: Device to resume.
787  * @rpmflags: Flag bits.
788  *
789  * If the RPM_GET_PUT flag is set, increment the device's usage count.  Then
790  * carry out a resume, either synchronous or asynchronous.
791  *
792  * This routine may be called in atomic context if the RPM_ASYNC flag is set.
793  */
794 int __pm_runtime_resume(struct device *dev, int rpmflags)
795 {
796         unsigned long flags;
797         int retval;
798
799         if (rpmflags & RPM_GET_PUT)
800                 atomic_inc(&dev->power.usage_count);
801
802         spin_lock_irqsave(&dev->power.lock, flags);
803         retval = rpm_resume(dev, rpmflags);
804         spin_unlock_irqrestore(&dev->power.lock, flags);
805
806         return retval;
807 }
808 EXPORT_SYMBOL_GPL(__pm_runtime_resume);
809
810 /**
811  * __pm_runtime_set_status - Set runtime PM status of a device.
812  * @dev: Device to handle.
813  * @status: New runtime PM status of the device.
814  *
815  * If runtime PM of the device is disabled or its power.runtime_error field is
816  * different from zero, the status may be changed either to RPM_ACTIVE, or to
817  * RPM_SUSPENDED, as long as that reflects the actual state of the device.
818  * However, if the device has a parent and the parent is not active, and the
819  * parent's power.ignore_children flag is unset, the device's status cannot be
820  * set to RPM_ACTIVE, so -EBUSY is returned in that case.
821  *
822  * If successful, __pm_runtime_set_status() clears the power.runtime_error field
823  * and the device parent's counter of unsuspended children is modified to
824  * reflect the new status.  If the new status is RPM_SUSPENDED, an idle
825  * notification request for the parent is submitted.
826  */
827 int __pm_runtime_set_status(struct device *dev, unsigned int status)
828 {
829         struct device *parent = dev->parent;
830         unsigned long flags;
831         bool notify_parent = false;
832         int error = 0;
833
834         if (status != RPM_ACTIVE && status != RPM_SUSPENDED)
835                 return -EINVAL;
836
837         spin_lock_irqsave(&dev->power.lock, flags);
838
839         if (!dev->power.runtime_error && !dev->power.disable_depth) {
840                 error = -EAGAIN;
841                 goto out;
842         }
843
844         if (dev->power.runtime_status == status)
845                 goto out_set;
846
847         if (status == RPM_SUSPENDED) {
848                 /* It always is possible to set the status to 'suspended'. */
849                 if (parent) {
850                         atomic_add_unless(&parent->power.child_count, -1, 0);
851                         notify_parent = !parent->power.ignore_children;
852                 }
853                 goto out_set;
854         }
855
856         if (parent) {
857                 spin_lock_nested(&parent->power.lock, SINGLE_DEPTH_NESTING);
858
859                 /*
860                  * It is invalid to put an active child under a parent that is
861                  * not active, has runtime PM enabled and the
862                  * 'power.ignore_children' flag unset.
863                  */
864                 if (!parent->power.disable_depth
865                     && !parent->power.ignore_children
866                     && parent->power.runtime_status != RPM_ACTIVE)
867                         error = -EBUSY;
868                 else if (dev->power.runtime_status == RPM_SUSPENDED)
869                         atomic_inc(&parent->power.child_count);
870
871                 spin_unlock(&parent->power.lock);
872
873                 if (error)
874                         goto out;
875         }
876
877  out_set:
878         __update_runtime_status(dev, status);
879         dev->power.runtime_error = 0;
880  out:
881         spin_unlock_irqrestore(&dev->power.lock, flags);
882
883         if (notify_parent)
884                 pm_request_idle(parent);
885
886         return error;
887 }
888 EXPORT_SYMBOL_GPL(__pm_runtime_set_status);
889
890 /**
891  * __pm_runtime_barrier - Cancel pending requests and wait for completions.
892  * @dev: Device to handle.
893  *
894  * Flush all pending requests for the device from pm_wq and wait for all
895  * runtime PM operations involving the device in progress to complete.
896  *
897  * Should be called under dev->power.lock with interrupts disabled.
898  */
899 static void __pm_runtime_barrier(struct device *dev)
900 {
901         pm_runtime_deactivate_timer(dev);
902
903         if (dev->power.request_pending) {
904                 dev->power.request = RPM_REQ_NONE;
905                 spin_unlock_irq(&dev->power.lock);
906
907                 cancel_work_sync(&dev->power.work);
908
909                 spin_lock_irq(&dev->power.lock);
910                 dev->power.request_pending = false;
911         }
912
913         if (dev->power.runtime_status == RPM_SUSPENDING
914             || dev->power.runtime_status == RPM_RESUMING
915             || dev->power.idle_notification) {
916                 DEFINE_WAIT(wait);
917
918                 /* Suspend, wake-up or idle notification in progress. */
919                 for (;;) {
920                         prepare_to_wait(&dev->power.wait_queue, &wait,
921                                         TASK_UNINTERRUPTIBLE);
922                         if (dev->power.runtime_status != RPM_SUSPENDING
923                             && dev->power.runtime_status != RPM_RESUMING
924                             && !dev->power.idle_notification)
925                                 break;
926                         spin_unlock_irq(&dev->power.lock);
927
928                         schedule();
929
930                         spin_lock_irq(&dev->power.lock);
931                 }
932                 finish_wait(&dev->power.wait_queue, &wait);
933         }
934 }
935
936 /**
937  * pm_runtime_barrier - Flush pending requests and wait for completions.
938  * @dev: Device to handle.
939  *
940  * Prevent the device from being suspended by incrementing its usage counter and
941  * if there's a pending resume request for the device, wake the device up.
942  * Next, make sure that all pending requests for the device have been flushed
943  * from pm_wq and wait for all runtime PM operations involving the device in
944  * progress to complete.
945  *
946  * Return value:
947  * 1, if there was a resume request pending and the device had to be woken up,
948  * 0, otherwise
949  */
950 int pm_runtime_barrier(struct device *dev)
951 {
952         int retval = 0;
953
954         pm_runtime_get_noresume(dev);
955         spin_lock_irq(&dev->power.lock);
956
957         if (dev->power.request_pending
958             && dev->power.request == RPM_REQ_RESUME) {
959                 rpm_resume(dev, 0);
960                 retval = 1;
961         }
962
963         __pm_runtime_barrier(dev);
964
965         spin_unlock_irq(&dev->power.lock);
966         pm_runtime_put_noidle(dev);
967
968         return retval;
969 }
970 EXPORT_SYMBOL_GPL(pm_runtime_barrier);
971
972 /**
973  * __pm_runtime_disable - Disable runtime PM of a device.
974  * @dev: Device to handle.
975  * @check_resume: If set, check if there's a resume request for the device.
976  *
977  * Increment power.disable_depth for the device and if was zero previously,
978  * cancel all pending runtime PM requests for the device and wait for all
979  * operations in progress to complete.  The device can be either active or
980  * suspended after its runtime PM has been disabled.
981  *
982  * If @check_resume is set and there's a resume request pending when
983  * __pm_runtime_disable() is called and power.disable_depth is zero, the
984  * function will wake up the device before disabling its runtime PM.
985  */
986 void __pm_runtime_disable(struct device *dev, bool check_resume)
987 {
988         spin_lock_irq(&dev->power.lock);
989
990         if (dev->power.disable_depth > 0) {
991                 dev->power.disable_depth++;
992                 goto out;
993         }
994
995         /*
996          * Wake up the device if there's a resume request pending, because that
997          * means there probably is some I/O to process and disabling runtime PM
998          * shouldn't prevent the device from processing the I/O.
999          */
1000         if (check_resume && dev->power.request_pending
1001             && dev->power.request == RPM_REQ_RESUME) {
1002                 /*
1003                  * Prevent suspends and idle notifications from being carried
1004                  * out after we have woken up the device.
1005                  */
1006                 pm_runtime_get_noresume(dev);
1007
1008                 rpm_resume(dev, 0);
1009
1010                 pm_runtime_put_noidle(dev);
1011         }
1012
1013         if (!dev->power.disable_depth++)
1014                 __pm_runtime_barrier(dev);
1015
1016  out:
1017         spin_unlock_irq(&dev->power.lock);
1018 }
1019 EXPORT_SYMBOL_GPL(__pm_runtime_disable);
1020
1021 /**
1022  * pm_runtime_enable - Enable runtime PM of a device.
1023  * @dev: Device to handle.
1024  */
1025 void pm_runtime_enable(struct device *dev)
1026 {
1027         unsigned long flags;
1028
1029         spin_lock_irqsave(&dev->power.lock, flags);
1030
1031         if (dev->power.disable_depth > 0)
1032                 dev->power.disable_depth--;
1033         else
1034                 dev_warn(dev, "Unbalanced %s!\n", __func__);
1035
1036         spin_unlock_irqrestore(&dev->power.lock, flags);
1037 }
1038 EXPORT_SYMBOL_GPL(pm_runtime_enable);
1039
1040 /**
1041  * pm_runtime_forbid - Block runtime PM of a device.
1042  * @dev: Device to handle.
1043  *
1044  * Increase the device's usage count and clear its power.runtime_auto flag,
1045  * so that it cannot be suspended at run time until pm_runtime_allow() is called
1046  * for it.
1047  */
1048 void pm_runtime_forbid(struct device *dev)
1049 {
1050         spin_lock_irq(&dev->power.lock);
1051         if (!dev->power.runtime_auto)
1052                 goto out;
1053
1054         dev->power.runtime_auto = false;
1055         atomic_inc(&dev->power.usage_count);
1056         rpm_resume(dev, 0);
1057
1058  out:
1059         spin_unlock_irq(&dev->power.lock);
1060 }
1061 EXPORT_SYMBOL_GPL(pm_runtime_forbid);
1062
1063 /**
1064  * pm_runtime_allow - Unblock runtime PM of a device.
1065  * @dev: Device to handle.
1066  *
1067  * Decrease the device's usage count and set its power.runtime_auto flag.
1068  */
1069 void pm_runtime_allow(struct device *dev)
1070 {
1071         spin_lock_irq(&dev->power.lock);
1072         if (dev->power.runtime_auto)
1073                 goto out;
1074
1075         dev->power.runtime_auto = true;
1076         if (atomic_dec_and_test(&dev->power.usage_count))
1077                 rpm_idle(dev, RPM_AUTO);
1078
1079  out:
1080         spin_unlock_irq(&dev->power.lock);
1081 }
1082 EXPORT_SYMBOL_GPL(pm_runtime_allow);
1083
1084 /**
1085  * pm_runtime_no_callbacks - Ignore runtime PM callbacks for a device.
1086  * @dev: Device to handle.
1087  *
1088  * Set the power.no_callbacks flag, which tells the PM core that this
1089  * device is power-managed through its parent and has no runtime PM
1090  * callbacks of its own.  The runtime sysfs attributes will be removed.
1091  */
1092 void pm_runtime_no_callbacks(struct device *dev)
1093 {
1094         spin_lock_irq(&dev->power.lock);
1095         dev->power.no_callbacks = 1;
1096         spin_unlock_irq(&dev->power.lock);
1097         if (device_is_registered(dev))
1098                 rpm_sysfs_remove(dev);
1099 }
1100 EXPORT_SYMBOL_GPL(pm_runtime_no_callbacks);
1101
1102 /**
1103  * pm_runtime_irq_safe - Leave interrupts disabled during callbacks.
1104  * @dev: Device to handle
1105  *
1106  * Set the power.irq_safe flag, which tells the PM core that the
1107  * ->runtime_suspend() and ->runtime_resume() callbacks for this device should
1108  * always be invoked with the spinlock held and interrupts disabled.  It also
1109  * causes the parent's usage counter to be permanently incremented, preventing
1110  * the parent from runtime suspending -- otherwise an irq-safe child might have
1111  * to wait for a non-irq-safe parent.
1112  */
1113 void pm_runtime_irq_safe(struct device *dev)
1114 {
1115         if (dev->parent)
1116                 pm_runtime_get_sync(dev->parent);
1117         spin_lock_irq(&dev->power.lock);
1118         dev->power.irq_safe = 1;
1119         spin_unlock_irq(&dev->power.lock);
1120 }
1121 EXPORT_SYMBOL_GPL(pm_runtime_irq_safe);
1122
1123 /**
1124  * update_autosuspend - Handle a change to a device's autosuspend settings.
1125  * @dev: Device to handle.
1126  * @old_delay: The former autosuspend_delay value.
1127  * @old_use: The former use_autosuspend value.
1128  *
1129  * Prevent runtime suspend if the new delay is negative and use_autosuspend is
1130  * set; otherwise allow it.  Send an idle notification if suspends are allowed.
1131  *
1132  * This function must be called under dev->power.lock with interrupts disabled.
1133  */
1134 static void update_autosuspend(struct device *dev, int old_delay, int old_use)
1135 {
1136         int delay = dev->power.autosuspend_delay;
1137
1138         /* Should runtime suspend be prevented now? */
1139         if (dev->power.use_autosuspend && delay < 0) {
1140
1141                 /* If it used to be allowed then prevent it. */
1142                 if (!old_use || old_delay >= 0) {
1143                         atomic_inc(&dev->power.usage_count);
1144                         rpm_resume(dev, 0);
1145                 }
1146         }
1147
1148         /* Runtime suspend should be allowed now. */
1149         else {
1150
1151                 /* If it used to be prevented then allow it. */
1152                 if (old_use && old_delay < 0)
1153                         atomic_dec(&dev->power.usage_count);
1154
1155                 /* Maybe we can autosuspend now. */
1156                 rpm_idle(dev, RPM_AUTO);
1157         }
1158 }
1159
1160 /**
1161  * pm_runtime_set_autosuspend_delay - Set a device's autosuspend_delay value.
1162  * @dev: Device to handle.
1163  * @delay: Value of the new delay in milliseconds.
1164  *
1165  * Set the device's power.autosuspend_delay value.  If it changes to negative
1166  * and the power.use_autosuspend flag is set, prevent runtime suspends.  If it
1167  * changes the other way, allow runtime suspends.
1168  */
1169 void pm_runtime_set_autosuspend_delay(struct device *dev, int delay)
1170 {
1171         int old_delay, old_use;
1172
1173         spin_lock_irq(&dev->power.lock);
1174         old_delay = dev->power.autosuspend_delay;
1175         old_use = dev->power.use_autosuspend;
1176         dev->power.autosuspend_delay = delay;
1177         update_autosuspend(dev, old_delay, old_use);
1178         spin_unlock_irq(&dev->power.lock);
1179 }
1180 EXPORT_SYMBOL_GPL(pm_runtime_set_autosuspend_delay);
1181
1182 /**
1183  * __pm_runtime_use_autosuspend - Set a device's use_autosuspend flag.
1184  * @dev: Device to handle.
1185  * @use: New value for use_autosuspend.
1186  *
1187  * Set the device's power.use_autosuspend flag, and allow or prevent runtime
1188  * suspends as needed.
1189  */
1190 void __pm_runtime_use_autosuspend(struct device *dev, bool use)
1191 {
1192         int old_delay, old_use;
1193
1194         spin_lock_irq(&dev->power.lock);
1195         old_delay = dev->power.autosuspend_delay;
1196         old_use = dev->power.use_autosuspend;
1197         dev->power.use_autosuspend = use;
1198         update_autosuspend(dev, old_delay, old_use);
1199         spin_unlock_irq(&dev->power.lock);
1200 }
1201 EXPORT_SYMBOL_GPL(__pm_runtime_use_autosuspend);
1202
1203 /**
1204  * pm_runtime_init - Initialize runtime PM fields in given device object.
1205  * @dev: Device object to initialize.
1206  */
1207 void pm_runtime_init(struct device *dev)
1208 {
1209         dev->power.runtime_status = RPM_SUSPENDED;
1210         dev->power.idle_notification = false;
1211
1212         dev->power.disable_depth = 1;
1213         atomic_set(&dev->power.usage_count, 0);
1214
1215         dev->power.runtime_error = 0;
1216
1217         atomic_set(&dev->power.child_count, 0);
1218         pm_suspend_ignore_children(dev, false);
1219         dev->power.runtime_auto = true;
1220
1221         dev->power.request_pending = false;
1222         dev->power.request = RPM_REQ_NONE;
1223         dev->power.deferred_resume = false;
1224         dev->power.accounting_timestamp = jiffies;
1225         INIT_WORK(&dev->power.work, pm_runtime_work);
1226
1227         dev->power.timer_expires = 0;
1228         setup_timer(&dev->power.suspend_timer, pm_suspend_timer_fn,
1229                         (unsigned long)dev);
1230
1231         init_waitqueue_head(&dev->power.wait_queue);
1232 }
1233
1234 /**
1235  * pm_runtime_remove - Prepare for removing a device from device hierarchy.
1236  * @dev: Device object being removed from device hierarchy.
1237  */
1238 void pm_runtime_remove(struct device *dev)
1239 {
1240         __pm_runtime_disable(dev, false);
1241
1242         /* Change the status back to 'suspended' to match the initial status. */
1243         if (dev->power.runtime_status == RPM_ACTIVE)
1244                 pm_runtime_set_suspended(dev);
1245         if (dev->power.irq_safe && dev->parent)
1246                 pm_runtime_put_sync(dev->parent);
1247 }