[ERD][NEUS7920-76] [COMMON] lib: dss: refactor dbg_snapshot_suspend logging

Previously dbg_snapshot_suspend was wrong by logging in
notifier function. This patch fixes it and adding various logging
when suspending and resuming this system.
Now dbg_snapshot_suspend logging is used when analyzing
various issues.

Change-Id: I024a23bfeb995ccd6f6b1ba2831bc85ee4404afd
Signed-off-by: Hosung Kim <hosung0.kim@samsung.com>

diff --git a/drivers/base/power/main.c b/drivers/base/power/main.c
index 885de2e96e6139e676438104f4aeeb63f79af0c9..0e23e78f1324e323e63edb1c5d96d8588022293c 100644 (file)
--- a/drivers/base/power/main.c
+++ b/drivers/base/power/main.c
@@ -452,7 +452,9 @@ static int dpm_run_callback(pm_callback_t cb, struct device *dev,
 
        pm_dev_dbg(dev, state, info);
        trace_device_pm_callback_start(dev, info, state.event);
+       dbg_snapshot_suspend((char *)info, cb, dev, state.event, DSS_FLAG_IN);
        error = cb(dev);
+       dbg_snapshot_suspend((char *)info, cb, dev, state.event, DSS_FLAG_OUT);
        trace_device_pm_callback_end(dev, error);
        suspend_report_result(cb, error);
 
@@ -606,6 +608,8 @@ void dpm_noirq_resume_devices(pm_message_t state)
        ktime_t starttime = ktime_get();
 
        trace_suspend_resume(TPS("dpm_resume_noirq"), state.event, true);
+       dbg_snapshot_suspend("dpm_resume_noirq", dpm_noirq_resume_devices,
+                               NULL, state.event, DSS_FLAG_IN);
        mutex_lock(&dpm_list_mtx);
        pm_transition = state;
 
@@ -646,6 +650,8 @@ void dpm_noirq_resume_devices(pm_message_t state)
        mutex_unlock(&dpm_list_mtx);
        async_synchronize_full();
        dpm_show_time(starttime, state, 0, "noirq");
+       dbg_snapshot_suspend("dpm_resume_noirq", dpm_noirq_resume_devices,
+                               NULL, state.event, DSS_FLAG_OUT);
        trace_suspend_resume(TPS("dpm_resume_noirq"), state.event, false);
 }
 
@@ -746,6 +752,8 @@ void dpm_resume_early(pm_message_t state)
        ktime_t starttime = ktime_get();
 
        trace_suspend_resume(TPS("dpm_resume_early"), state.event, true);
+       dbg_snapshot_suspend("dpm_resume_early", dpm_resume_early,
+                               NULL, state.event, DSS_FLAG_IN);
        mutex_lock(&dpm_list_mtx);
        pm_transition = state;
 
@@ -785,6 +793,8 @@ void dpm_resume_early(pm_message_t state)
        mutex_unlock(&dpm_list_mtx);
        async_synchronize_full();
        dpm_show_time(starttime, state, 0, "early");
+       dbg_snapshot_suspend("dpm_resume_early", dpm_resume_early,
+                               NULL, state.event, DSS_FLAG_OUT);
        trace_suspend_resume(TPS("dpm_resume_early"), state.event, false);
 }
 
@@ -921,6 +931,8 @@ void dpm_resume(pm_message_t state)
        ktime_t starttime = ktime_get();
 
        trace_suspend_resume(TPS("dpm_resume"), state.event, true);
+       dbg_snapshot_suspend("dpm_resume", dpm_resume,
+                               NULL, state.event, DSS_FLAG_IN);
        might_sleep();
 
        mutex_lock(&dpm_list_mtx);
@@ -962,6 +974,8 @@ void dpm_resume(pm_message_t state)
        dpm_show_time(starttime, state, 0, NULL);
 
        cpufreq_resume();
+       dbg_snapshot_suspend("dpm_resume", dpm_resume,
+                               NULL, state.event, DSS_FLAG_OUT);
        trace_suspend_resume(TPS("dpm_resume"), state.event, false);
 }
 
@@ -1021,6 +1035,8 @@ void dpm_complete(pm_message_t state)
        struct list_head list;
 
        trace_suspend_resume(TPS("dpm_complete"), state.event, true);
+       dbg_snapshot_suspend("dpm_complete", dpm_complete,
+                               NULL, state.event, DSS_FLAG_OUT);
        might_sleep();
 
        INIT_LIST_HEAD(&list);
@@ -1045,6 +1061,8 @@ void dpm_complete(pm_message_t state)
 
        /* Allow device probing and trigger re-probing of deferred devices */
        device_unblock_probing();
+       dbg_snapshot_suspend("dpm_complete", dpm_complete,
+                               NULL, state.event, DSS_FLAG_OUT);
        trace_suspend_resume(TPS("dpm_complete"), state.event, false);
 }
 
@@ -1187,6 +1205,8 @@ int dpm_noirq_suspend_devices(pm_message_t state)
        int error = 0;
 
        trace_suspend_resume(TPS("dpm_suspend_noirq"), state.event, true);
+       dbg_snapshot_suspend("dpm_suspend_noirq", dpm_noirq_suspend_devices,
+                               NULL, state.event, DSS_FLAG_IN);
        mutex_lock(&dpm_list_mtx);
        pm_transition = state;
        async_error = 0;
@@ -1223,6 +1243,8 @@ int dpm_noirq_suspend_devices(pm_message_t state)
                dpm_save_failed_step(SUSPEND_SUSPEND_NOIRQ);
        }
        dpm_show_time(starttime, state, error, "noirq");
+       dbg_snapshot_suspend("dpm_suspend_noirq", dpm_noirq_suspend_devices,
+                               NULL, state.event, DSS_FLAG_OUT);
        trace_suspend_resume(TPS("dpm_suspend_noirq"), state.event, false);
        return error;
 }
@@ -1345,6 +1367,8 @@ int dpm_suspend_late(pm_message_t state)
        int error = 0;
 
        trace_suspend_resume(TPS("dpm_suspend_late"), state.event, true);
+       dbg_snapshot_suspend("dpm_suspend_late", dpm_suspend_late,
+                               NULL, state.event, DSS_FLAG_IN);
        mutex_lock(&dpm_list_mtx);
        pm_transition = state;
        async_error = 0;
@@ -1382,6 +1406,8 @@ int dpm_suspend_late(pm_message_t state)
                dpm_resume_early(resume_event(state));
        }
        dpm_show_time(starttime, state, error, "late");
+       dbg_snapshot_suspend("dpm_suspend_late", dpm_suspend_late,
+                               NULL, state.event, DSS_FLAG_OUT);
        trace_suspend_resume(TPS("dpm_suspend_late"), state.event, false);
        return error;
 }
@@ -1621,6 +1647,7 @@ int dpm_suspend(pm_message_t state)
        int error = 0;
 
        trace_suspend_resume(TPS("dpm_suspend"), state.event, true);
+       dbg_snapshot_suspend("dpm_suspend", dpm_suspend, NULL, state.event, DSS_FLAG_IN);
        might_sleep();
 
        cpufreq_suspend();
@@ -1658,6 +1685,7 @@ int dpm_suspend(pm_message_t state)
                dpm_save_failed_step(SUSPEND_SUSPEND);
        }
        dpm_show_time(starttime, state, error, NULL);
+       dbg_snapshot_suspend("dpm_suspend", dpm_suspend, NULL, state.event, DSS_FLAG_OUT);
        trace_suspend_resume(TPS("dpm_suspend"), state.event, false);
        return error;
 }
@@ -1707,8 +1735,10 @@ static int device_prepare(struct device *dev, pm_message_t state)
        if (!callback && dev->driver && dev->driver->pm)
                callback = dev->driver->pm->prepare;
 
+       dbg_snapshot_suspend("device_prepare", callback, dev, state.event, DSS_FLAG_IN);
        if (callback)
                ret = callback(dev);
+       dbg_snapshot_suspend("device_prepare", callback, dev, state.event, DSS_FLAG_OUT);
 
 unlock:
        device_unlock(dev);
@@ -1742,6 +1772,8 @@ int dpm_prepare(pm_message_t state)
        int error = 0;
 
        trace_suspend_resume(TPS("dpm_prepare"), state.event, true);
+       dbg_snapshot_suspend("dpm_prepare", dpm_prepare,
+                               NULL, state.event, DSS_FLAG_IN);
        might_sleep();
 
        /*
@@ -1788,6 +1820,8 @@ int dpm_prepare(pm_message_t state)
                put_device(dev);
        }
        mutex_unlock(&dpm_list_mtx);
+       dbg_snapshot_suspend("dpm_prepare", dpm_prepare,
+                               NULL, state.event, DSS_FLAG_OUT);
        trace_suspend_resume(TPS("dpm_prepare"), state.event, false);
        return error;
 }

diff --git a/drivers/base/syscore.c b/drivers/base/syscore.c
index 96c34a95cc625929a08ca0e76c13b9b830a4907c..516f833adc18bf0d6e71a7715458898443bb78d2 100644 (file)
--- a/drivers/base/syscore.c
+++ b/drivers/base/syscore.c
@@ -65,7 +65,9 @@ int syscore_suspend(void)
                if (ops->suspend) {
                        if (initcall_debug)
                                pr_info("PM: Calling %pF\n", ops->suspend);
+                       dbg_snapshot_suspend("syscore_suspend", ops->suspend, NULL, 0, DSS_FLAG_IN);
                        ret = ops->suspend();
+                       dbg_snapshot_suspend("syscore_suspend", ops->suspend, NULL, 0, DSS_FLAG_OUT);
                        if (ret)
                                goto err_out;
                        WARN_ONCE(!irqs_disabled(),
@@ -105,7 +107,9 @@ void syscore_resume(void)
                if (ops->resume) {
                        if (initcall_debug)
                                pr_info("PM: Calling %pF\n", ops->resume);
+                       dbg_snapshot_suspend("syscore_resume", ops->resume, NULL, 0, DSS_FLAG_IN);
                        ops->resume();
+                       dbg_snapshot_suspend("syscore_resume", ops->resume, NULL, 0, DSS_FLAG_OUT);
                        WARN_ONCE(!irqs_disabled(),
                                "Interrupts enabled after %pF\n", ops->resume);
                }
@@ -127,7 +131,9 @@ void syscore_shutdown(void)
                if (ops->shutdown) {
                        if (initcall_debug)
                                pr_info("PM: Calling %pF\n", ops->shutdown);
+                       dbg_snapshot_suspend("syscore_shutdown", ops->shutdown, NULL, 0, DSS_FLAG_IN);
                        ops->shutdown();
+                       dbg_snapshot_suspend("syscore_shutdown", ops->shutdown, NULL, 0, DSS_FLAG_OUT);
                }
 
        mutex_unlock(&syscore_ops_lock);

diff --git a/include/linux/debug-snapshot.h b/include/linux/debug-snapshot.h
index 7605449b1673dbf0a1c9aa18064760bf4c211a45..2961dca8ed457fdac7cfbd4e376d78704d54f9c9 100644 (file)
--- a/include/linux/debug-snapshot.h
+++ b/include/linux/debug-snapshot.h
@@ -23,7 +23,7 @@
 extern void dbg_snapshot_task(int cpu, void *v_task);
 extern void dbg_snapshot_work(void *worker, void *v_task, void *fn, int en);
 extern void dbg_snapshot_cpuidle(char *modes, unsigned state, int diff, int en);
-extern void dbg_snapshot_suspend(void *fn, void *dev, int en);
+extern void dbg_snapshot_suspend(char *log, void *fn, void *dev, int state, int en);
 extern void dbg_snapshot_irq(int irq, void *fn, void *val, int en);
 extern void dbg_snapshot_print_notifier_call(void **nl, unsigned long func, int en);
 extern int dbg_snapshot_try_enable(const char *name, unsigned long long duration);
@@ -191,7 +191,7 @@ extern void dbg_snapshot_binder(struct trace_binder_transaction_base *base,
 #define dbg_snapshot_work(a,b,c,d)             do { } while(0)
 #define dbg_snapshot_clockevent(a,b,c) do { } while(0)
 #define dbg_snapshot_cpuidle(a,b,c,d)  do { } while(0)
-#define dbg_snapshot_suspend(a,b,c)    do { } while(0)
+#define dbg_snapshot_suspend(a,b,c,d,e)        do { } while(0)
 #define dbg_snapshot_regulator(a,b,c,d,e,f)    do { } while(0)
 #define dbg_snapshot_thermal(a,b,c,d)  do { } while(0)
 #define dbg_snapshot_irq(a,b,c,d)              do { } while(0)
@@ -259,6 +259,7 @@ static inline void dbg_snapshot_spin_func(void) {do {wfi();} while(1);}
 
 extern struct atomic_notifier_head restart_handler_list;
 extern struct blocking_notifier_head reboot_notifier_list;
+extern struct blocking_notifier_head pm_chain_head;
 
 #ifdef CONFIG_EXYNOS_ITMON
 extern struct atomic_notifier_head itmon_notifier_list;

diff --git a/kernel/cpu.c b/kernel/cpu.c
index 0aa6637bb1027d3b4a7c6059d6a4790d98eb589e..63a28b94b6ac54f24fe0f50d0c9eee874e7b51ff 100644 (file)
--- a/kernel/cpu.c
+++ b/kernel/cpu.c
@@ -1608,7 +1608,9 @@ int freeze_secondary_cpus(int primary)
                if (cpu == primary)
                        continue;
                trace_suspend_resume(TPS("CPU_OFF"), cpu, true);
+               dbg_snapshot_suspend("CPU_OFF", _cpu_down, NULL, cpu, DSS_FLAG_IN);
                error = _cpu_down(cpu, 1, CPUHP_OFFLINE);
+               dbg_snapshot_suspend("CPU_OFF", _cpu_down, NULL, cpu, DSS_FLAG_OUT);
                trace_suspend_resume(TPS("CPU_OFF"), cpu, false);
                if (!error)
                        cpumask_set_cpu(cpu, frozen_cpus);
@@ -1659,7 +1661,9 @@ void enable_nonboot_cpus(void)
 
        for_each_cpu(cpu, frozen_cpus) {
                trace_suspend_resume(TPS("CPU_ON"), cpu, true);
+               dbg_snapshot_suspend("CPU_ON", _cpu_up, NULL, cpu, DSS_FLAG_IN);
                error = _cpu_up(cpu, 1, CPUHP_ONLINE);
+               dbg_snapshot_suspend("CPU_ON", _cpu_up, NULL, cpu, DSS_FLAG_OUT);
                trace_suspend_resume(TPS("CPU_ON"), cpu, false);
                if (!error) {
                        pr_info("CPU%d is up\n", cpu);

diff --git a/kernel/power/hibernate.c b/kernel/power/hibernate.c
index a5c36e9c56a670c59cabe20376f2ce1aedcd5e8a..90b5ce9be90e17ee3e94d232b9cc8aa86a6eecd4 100644 (file)
--- a/kernel/power/hibernate.c
+++ b/kernel/power/hibernate.c
@@ -299,9 +299,13 @@ static int create_image(int platform_mode)
        in_suspend = 1;
        save_processor_state();
        trace_suspend_resume(TPS("machine_suspend"), PM_EVENT_HIBERNATE, true);
+       dbg_snapshot_suspend("machine_suspend", swsusp_arch_suspend,
+                               NULL, PM_EVENT_HIBERNATE, DSS_FLAG_IN);
        error = swsusp_arch_suspend();
        /* Restore control flow magically appears here */
        restore_processor_state();
+       dbg_snapshot_suspend("machine_suspend", swsusp_arch_suspend,
+                               NULL, PM_EVENT_HIBERNATE, DSS_FLAG_OUT);
        trace_suspend_resume(TPS("machine_suspend"), PM_EVENT_HIBERNATE, false);
        if (error)
                pr_err("Error %d creating hibernation image\n", error);

diff --git a/kernel/power/main.c b/kernel/power/main.c
index 3a2ca9066583fad36e3b91fe99515058d453a62e..c214e35d060377da57a9c2037f0a67df86fd2d23 100644 (file)
--- a/kernel/power/main.c
+++ b/kernel/power/main.c
@@ -24,7 +24,7 @@ DEFINE_MUTEX(pm_mutex);
 
 /* Routines for PM-transition notifications */
 
-static BLOCKING_NOTIFIER_HEAD(pm_chain_head);
+BLOCKING_NOTIFIER_HEAD(pm_chain_head);
 
 int register_pm_notifier(struct notifier_block *nb)
 {

diff --git a/kernel/power/process.c b/kernel/power/process.c
index c366e3d34a0721708b027e8c3a88d9bd6bb57184..5aba86d73715e1257ddbc38a7c8eeebc4f1366a0 100644 (file)
--- a/kernel/power/process.c
+++ b/kernel/power/process.c
@@ -202,6 +202,7 @@ void thaw_processes(void)
        struct task_struct *curr = current;
 
        trace_suspend_resume(TPS("thaw_processes"), 0, true);
+       dbg_snapshot_suspend("thaw_processes", thaw_processes, NULL, 0, DSS_FLAG_IN);
        if (pm_freezing)
                atomic_dec(&system_freezing_cnt);
        pm_freezing = false;
@@ -231,6 +232,7 @@ void thaw_processes(void)
 
        schedule();
        pr_cont("done.\n");
+       dbg_snapshot_suspend("thaw_processes", thaw_processes, NULL, 0, DSS_FLAG_OUT);
        trace_suspend_resume(TPS("thaw_processes"), 0, false);
 }
 

diff --git a/kernel/power/suspend.c b/kernel/power/suspend.c
index 4789ca7e1019f6b92275c14dae60bf094abcda2c..06a118fb6ded975287800dd6f2e9b06d7a6994d6 100644 (file)
--- a/kernel/power/suspend.c
+++ b/kernel/power/suspend.c
@@ -78,6 +78,8 @@ static void s2idle_begin(void)
 static void s2idle_enter(void)
 {
        trace_suspend_resume(TPS("machine_suspend"), PM_SUSPEND_TO_IDLE, true);
+       dbg_snapshot_suspend("machine_suspend", s2idle_enter, NULL,
+                               PM_SUSPEND_TO_IDLE, DSS_FLAG_IN);
 
        raw_spin_lock_irq(&s2idle_lock);
        if (pm_wakeup_pending())
@@ -104,6 +106,8 @@ static void s2idle_enter(void)
        s2idle_state = S2IDLE_STATE_NONE;
        raw_spin_unlock_irq(&s2idle_lock);
 
+       dbg_snapshot_suspend("machine_suspend", s2idle_enter, NULL,
+                               PM_SUSPEND_TO_IDLE, DSS_FLAG_OUT);
        trace_suspend_resume(TPS("machine_suspend"), PM_SUSPEND_TO_IDLE, false);
 }
 
@@ -356,7 +360,11 @@ static int suspend_prepare(suspend_state_t state)
        }
 
        trace_suspend_resume(TPS("freeze_processes"), 0, true);
+       dbg_snapshot_suspend("freeze_processes", suspend_freeze_processes,
+                               NULL, 0, DSS_FLAG_IN);
        error = suspend_freeze_processes();
+       dbg_snapshot_suspend("freeze_processes", suspend_freeze_processes,
+                               NULL, 0, DSS_FLAG_OUT);
        trace_suspend_resume(TPS("freeze_processes"), 0, false);
        if (!error)
                return 0;
@@ -446,7 +454,11 @@ static int suspend_enter(suspend_state_t state, bool *wakeup)
                if (!(suspend_test(TEST_CORE) || *wakeup)) {
                        trace_suspend_resume(TPS("machine_suspend"),
                                state, true);
+                       dbg_snapshot_suspend("machine_suspend", suspend_ops->enter,
+                                               NULL, state, DSS_FLAG_IN);
                        error = suspend_ops->enter(state);
+                       dbg_snapshot_suspend("machine_suspend", suspend_ops->enter,
+                                               NULL, state, DSS_FLAG_OUT);
                        trace_suspend_resume(TPS("machine_suspend"),
                                state, false);
                } else if (*wakeup) {
@@ -518,9 +530,12 @@ int suspend_devices_and_enter(suspend_state_t state)
        dpm_resume_end(PMSG_RESUME);
        suspend_test_finish("resume devices");
        trace_suspend_resume(TPS("resume_console"), state, true);
+       dbg_snapshot_suspend("resume_console", resume_console,
+                               NULL, state, DSS_FLAG_IN);
        resume_console();
+       dbg_snapshot_suspend("resume_console", resume_console,
+                               NULL, state, DSS_FLAG_OUT);
        trace_suspend_resume(TPS("resume_console"), state, false);
-
  Close:
        platform_resume_end(state);
        pm_suspend_target_state = PM_SUSPEND_ON;
@@ -557,6 +572,7 @@ static int enter_state(suspend_state_t state)
        int error;
 
        trace_suspend_resume(TPS("suspend_enter"), state, true);
+       dbg_snapshot_suspend("suspend_enter", enter_state, NULL, state, DSS_FLAG_IN);
        if (state == PM_SUSPEND_TO_IDLE) {
 #ifdef CONFIG_PM_DEBUG
                if (pm_test_level != TEST_NONE && pm_test_level <= TEST_CPUS) {
@@ -575,9 +591,11 @@ static int enter_state(suspend_state_t state)
 
 #ifndef CONFIG_SUSPEND_SKIP_SYNC
        trace_suspend_resume(TPS("sync_filesystems"), 0, true);
+       dbg_snapshot_suspend("sync_filesystems", sys_sync, NULL, state, DSS_FLAG_IN);
        pr_info("Syncing filesystems ... ");
        sys_sync();
        pr_cont("done.\n");
+       dbg_snapshot_suspend("sync_filesystems", sys_sync, NULL, state, DSS_FLAG_OUT);
        trace_suspend_resume(TPS("sync_filesystems"), 0, false);
 #endif
 
@@ -590,6 +608,7 @@ static int enter_state(suspend_state_t state)
        if (suspend_test(TEST_FREEZER))
                goto Finish;
 
+       dbg_snapshot_suspend("suspend_enter", enter_state, NULL, state, DSS_FLAG_OUT);
        trace_suspend_resume(TPS("suspend_enter"), state, false);
        pm_pr_dbg("Suspending system (%s)\n", mem_sleep_labels[state]);
        pm_restrict_gfp_mask();

diff --git a/kernel/time/tick-common.c b/kernel/time/tick-common.c
index 49edc1c4f3e645894f839c40489ab81594a02398..5ee818b2d368b0ba44c7e95d83379886f2a9a67b 100644 (file)
--- a/kernel/time/tick-common.c
+++ b/kernel/time/tick-common.c
@@ -490,6 +490,8 @@ void tick_freeze(void)
        if (tick_freeze_depth == num_online_cpus()) {
                trace_suspend_resume(TPS("timekeeping_freeze"),
                                     smp_processor_id(), true);
+               dbg_snapshot_suspend("timekeeping_freeze", timekeeping_suspend,
+                                       NULL, smp_processor_id(), DSS_FLAG_IN);
                timekeeping_suspend();
        } else {
                tick_suspend_local();
@@ -513,6 +515,8 @@ void tick_unfreeze(void)
 
        if (tick_freeze_depth == num_online_cpus()) {
                timekeeping_resume();
+               dbg_snapshot_suspend("timekeeping_freeze", timekeeping_suspend,
+                                       NULL, smp_processor_id(), DSS_FLAG_OUT);
                trace_suspend_resume(TPS("timekeeping_freeze"),
                                     smp_processor_id(), false);
        } else {

diff --git a/lib/debug-snapshot-log.c b/lib/debug-snapshot-log.c
index 028c2fc48cd1f1e6378758f114d7760f1aba7e31..77838950441b07f924ea6cdb1996918007ef0b5d 100644 (file)
--- a/lib/debug-snapshot-log.c
+++ b/lib/debug-snapshot-log.c
@@ -29,6 +29,7 @@
 #include <asm/traps.h>
 #include <asm/hardirq.h>
 #include <asm/stacktrace.h>
+#include <asm/arch_timer.h>
 #include <linux/debug-snapshot.h>
 #include <linux/kernel_stat.h>
 #include <linux/irqnr.h>
@@ -694,19 +695,30 @@ void dbg_snapshot_cpuidle(char *modes, unsigned state, int diff, int en)
        }
 }
 
-void dbg_snapshot_suspend(void *fn, void *dev, int en)
+void dbg_snapshot_suspend(char *log, void *fn, void *dev, int state, int en)
 {
        struct dbg_snapshot_item *item = &dss_items[dss_desc.kevents_num];
 
        if (unlikely(!dss_base.enabled || !item->entry.enabled))
                return;
        {
+               int len;
                int cpu = raw_smp_processor_id();
                unsigned long i = atomic_inc_return(&dss_idx.suspend_log_idx) &
                                (ARRAY_SIZE(dss_log->suspend) - 1);
 
                dss_log->suspend[i].time = cpu_clock(cpu);
                dss_log->suspend[i].sp = (unsigned long) current_stack_pointer;
+
+               if (log) {
+                       len = strlen(log);
+                       memcpy(dss_log->suspend[i].log, log,
+                                       len < DSS_LOG_GEN_LEN ?
+                                       len : DSS_LOG_GEN_LEN - 1);
+               } else {
+                       memset(dss_log->suspend[i].log, 0, DSS_LOG_GEN_LEN - 1);
+               }
+
                dss_log->suspend[i].fn = fn;
                dss_log->suspend[i].dev = (struct device *)dev;
                dss_log->suspend[i].core = cpu;
@@ -1060,6 +1072,9 @@ static struct notifier_block **dss_should_check_nl[] = {
        (struct notifier_block **)(&panic_notifier_list.head),
        (struct notifier_block **)(&reboot_notifier_list.head),
        (struct notifier_block **)(&restart_handler_list.head),
+#ifdef CONFIG_PM_SLEEP
+       (struct notifier_block **)(&pm_chain_head.head),
+#endif
 #ifdef CONFIG_EXYNOS_ITMON
        (struct notifier_block **)(&itmon_notifier_list.head),
 #endif

diff --git a/lib/debug-snapshot-log.h b/lib/debug-snapshot-log.h
index 78104afbf4f0ffc5310a4eb3a316354f44a7212a..68bab912ff09b42bcae66ad4c6b7d7e101c0a92e 100644 (file)
--- a/lib/debug-snapshot-log.h
+++ b/lib/debug-snapshot-log.h
@@ -36,7 +36,8 @@
 #define DSS_SPARE_SZ                   (DSS_HEADER_SIZE - DSS_HEADER_TOTAL_SZ)
 
 /*  Length domain */
-#define DSS_LOG_STRING_LENGTH          SZ_128
+#define DSS_LOG_STRING_LEN             SZ_128
+#define DSS_LOG_GEN_LEN                        SZ_16
 #define DSS_MMU_REG_OFFSET             SZ_512
 #define DSS_CORE_REG_OFFSET            SZ_512
 #define DSS_LOG_MAX_NUM                        SZ_1K
@@ -118,6 +119,7 @@ struct dbg_snapshot_log {
        struct __suspend_log {
                unsigned long long time;
                unsigned long sp;
+               char log[DSS_LOG_GEN_LEN];
                void *fn;
 #ifdef CONFIG_DEBUG_SNAPSHOT_LINUX_BUILD
                struct device *dev;
@@ -125,6 +127,7 @@ struct dbg_snapshot_log {
                void *dev;
 #endif
                int en;
+               int state;
                int core;
        } suspend[DSS_LOG_MAX_NUM * 4];
 
@@ -354,7 +357,7 @@ struct dbg_snapshot_log {
        struct __printk_log {
                unsigned long long time;
                int cpu;
-               char log[DSS_LOG_STRING_LENGTH];
+               char log[DSS_LOG_STRING_LEN];
                void *caller[DSS_CALLSTACK_MAX_NUM];
        } printk[DSS_API_MAX_NUM];
 #endif