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