← Back to branch summary

~ubuntu-branches/ubuntu/quantal/linux-linaro-mx51/quantal

« back to all changes in this revision

Viewing changes to drivers/base/power/main.c

  • Committer: Package Import Robot
  • Author(s): John Rigby, John Rigby
  • Date: 2011-09-26 10:44:23 UTC
  • Revision ID: package-import@ubuntu.com-20110926104423-3o58a3c1bj7x00rs
Tags: 3.0.0-1007.9
https://launchpad.net/bugs/826021
[ John Rigby ]

Enable crypto modules and remove crypto-modules from
exclude-module files
LP: #826021

Show diffs side-by-side

added added

removed removed

Lines of Context:
drivers/base/power/main.c
57
57
 */
58
58
void device_pm_init(struct device *dev)
59
59
{
60
 
        dev->power.in_suspend = false;
 
60
        dev->power.is_prepared = false;
 
61
        dev->power.is_suspended = false;
61
62
        init_completion(&dev->power.completion);
62
63
        complete_all(&dev->power.completion);
63
64
        dev->power.wakeup = NULL;
91
92
        pr_debug("PM: Adding info for %s:%s\n",
92
93
                 dev->bus ? dev->bus->name : "No Bus", dev_name(dev));
93
94
        mutex_lock(&dpm_list_mtx);
94
 
        if (dev->parent && dev->parent->power.in_suspend)
 
95
        if (dev->parent && dev->parent->power.is_prepared)
95
96
                dev_warn(dev, "parent %s should not be sleeping\n",
96
97
                        dev_name(dev->parent));
97
98
        list_add_tail(&dev->power.entry, &dpm_list);
390
391
                dev_name(dev), pm_verb(state.event), info, error);
391
392
}
392
393
 
 
394
static void device_show_time(struct device *dev, ktime_t starttime, pm_message_t state, char *info)
 
395
{
 
396
        ktime_t calltime;
 
397
        s64 usecs64;
 
398
        int usecs;
 
399
 
 
400
        calltime = ktime_get();
 
401
        usecs64 = ktime_to_ns(ktime_sub(calltime, starttime));
 
402
        do_div(usecs64, NSEC_PER_USEC);
 
403
        usecs = usecs64;
 
404
        if (usecs == 0)
 
405
                usecs = 1;
 
406
        if ((usecs / USEC_PER_MSEC) > CONFIG_SR_REPORT_TIME_LIMIT)
 
407
                pr_info("PM: %s%s%s of drv:%s dev:%s complete after %ld.%03ld msecs\n", info ?: "", info ? " " : "", pm_verb(state.event),
 
408
                dev_driver_string(dev), dev_name(dev), usecs / USEC_PER_MSEC,
 
409
                usecs % USEC_PER_MSEC);
 
410
}
 
411
 
393
412
static void dpm_show_time(ktime_t starttime, pm_message_t state, char *info)
394
413
{
395
414
        ktime_t calltime;
420
439
static int device_resume_noirq(struct device *dev, pm_message_t state)
421
440
{
422
441
        int error = 0;
 
442
        ktime_t starttime = ktime_get();
423
443
 
424
444
        TRACE_DEVICE(dev);
425
445
        TRACE_RESUME(0);
427
447
        if (dev->pwr_domain) {
428
448
                pm_dev_dbg(dev, state, "EARLY power domain ");
429
449
                error = pm_noirq_op(dev, &dev->pwr_domain->ops, state);
 
450
                device_show_time(dev, starttime, state, "early");
430
451
        } else if (dev->type && dev->type->pm) {
431
452
                pm_dev_dbg(dev, state, "EARLY type ");
432
453
                error = pm_noirq_op(dev, dev->type->pm, state);
504
525
static int device_resume(struct device *dev, pm_message_t state, bool async)
505
526
{
506
527
        int error = 0;
 
528
        ktime_t starttime = ktime_get();
507
529
 
508
530
        TRACE_DEVICE(dev);
509
531
        TRACE_RESUME(0);
511
533
        dpm_wait(dev->parent, async);
512
534
        device_lock(dev);
513
535
 
514
 
        dev->power.in_suspend = false;
 
536
        /*
 
537
         * This is a fib.  But we'll allow new children to be added below
 
538
         * a resumed device, even if the device hasn't been completed yet.
 
539
         */
 
540
        dev->power.is_prepared = false;
 
541
 
 
542
        if (!dev->power.is_suspended)
 
543
                goto Unlock;
515
544
 
516
545
        if (dev->pwr_domain) {
517
546
                pm_dev_dbg(dev, state, "power domain ");
547
576
                }
548
577
        }
549
578
 
 
579
        device_show_time(dev, starttime, state, NULL);
550
580
 End:
 
581
        dev->power.is_suspended = false;
 
582
 
 
583
 Unlock:
551
584
        device_unlock(dev);
552
585
        complete_all(&dev->power.completion);
553
586
 
670
703
                struct device *dev = to_device(dpm_prepared_list.prev);
671
704
 
672
705
                get_device(dev);
673
 
                dev->power.in_suspend = false;
 
706
                dev->power.is_prepared = false;
674
707
                list_move(&dev->power.entry, &list);
675
708
                mutex_unlock(&dpm_list_mtx);
676
709
 
732
765
static int device_suspend_noirq(struct device *dev, pm_message_t state)
733
766
{
734
767
        int error;
 
768
        ktime_t starttime = ktime_get();
735
769
 
736
770
        if (dev->pwr_domain) {
737
771
                pm_dev_dbg(dev, state, "LATE power domain ");
753
787
                error = pm_noirq_op(dev, dev->bus->pm, state);
754
788
                if (error)
755
789
                        return error;
 
790
                device_show_time(dev, starttime, state, "late");
756
791
        }
757
792
 
758
793
        return 0;
830
865
static int __device_suspend(struct device *dev, pm_message_t state, bool async)
831
866
{
832
867
        int error = 0;
 
868
        ktime_t starttime = ktime_get();
833
869
 
834
870
        dpm_wait_for_children(dev, async);
835
871
        device_lock(dev);
836
872
 
837
873
        if (async_error)
838
 
                goto End;
 
874
                goto Unlock;
839
875
 
840
876
        if (pm_wakeup_pending()) {
841
877
                async_error = -EBUSY;
842
 
                goto End;
 
878
                goto Unlock;
843
879
        }
844
880
 
845
881
        if (dev->pwr_domain) {
876
912
                }
877
913
        }
878
914
 
 
915
        device_show_time(dev, starttime, state, NULL);
879
916
 End:
 
917
        dev->power.is_suspended = !error;
 
918
 
 
919
 Unlock:
880
920
        device_unlock(dev);
881
921
        complete_all(&dev->power.completion);
882
922
 
1042
1082
                        put_device(dev);
1043
1083
                        break;
1044
1084
                }
1045
 
                dev->power.in_suspend = true;
 
1085
                dev->power.is_prepared = true;
1046
1086
                if (!list_empty(&dev->power.entry))
1047
1087
                        list_move_tail(&dev->power.entry, &dpm_prepared_list);
1048
1088
                put_device(dev);