2 * OMAP Power Management debug routines
4 * Copyright (C) 2005 Texas Instruments, Inc.
5 * Copyright (C) 2006-2008 Nokia Corporation
8 * Richard Woodruff <r-woodruff2@ti.com>
11 * Amit Kucheria <amit.kucheria@nokia.com>
12 * Igor Stoppa <igor.stoppa@nokia.com>
15 * Based on pm.c for omap2
17 * This program is free software; you can redistribute it and/or modify
18 * it under the terms of the GNU General Public License version 2 as
19 * published by the Free Software Foundation.
22 #include <linux/kernel.h>
23 #include <linux/sched.h>
24 #include <linux/clk.h>
25 #include <linux/err.h>
27 #include <linux/module.h>
28 #include <linux/slab.h>
30 #include <plat/clock.h>
31 #include <plat/board.h>
32 #include <plat/powerdomain.h>
33 #include <plat/clockdomain.h>
41 #define DUMP_PRM_MOD_REG(mod, reg) \
42 regs[reg_count].name = #mod "." #reg; \
43 regs[reg_count++].val = prm_read_mod_reg(mod, reg)
44 #define DUMP_CM_MOD_REG(mod, reg) \
45 regs[reg_count].name = #mod "." #reg; \
46 regs[reg_count++].val = cm_read_mod_reg(mod, reg)
47 #define DUMP_PRM_REG(reg) \
48 regs[reg_count].name = #reg; \
49 regs[reg_count++].val = __raw_readl(reg)
50 #define DUMP_CM_REG(reg) \
51 regs[reg_count].name = #reg; \
52 regs[reg_count++].val = __raw_readl(reg)
53 #define DUMP_INTC_REG(reg, off) \
54 regs[reg_count].name = #reg; \
55 regs[reg_count++].val = \
56 __raw_readl(OMAP2_L4_IO_ADDRESS(0x480fe000 + (off)))
58 void omap2_pm_dump(int mode
, int resume
, unsigned int us
)
65 const char *s1
= NULL
, *s2
= NULL
;
70 DUMP_PRM_MOD_REG(OCP_MOD
, OMAP2_PRM_IRQENABLE_MPU_OFFSET
);
71 DUMP_CM_MOD_REG(MPU_MOD
, OMAP2_CM_CLKSTCTRL
);
72 DUMP_PRM_MOD_REG(MPU_MOD
, OMAP2_PM_PWSTCTRL
);
73 DUMP_PRM_MOD_REG(MPU_MOD
, OMAP2_PM_PWSTST
);
74 DUMP_PRM_MOD_REG(MPU_MOD
, PM_WKDEP
);
78 DUMP_INTC_REG(INTC_MIR0
, 0x0084);
79 DUMP_INTC_REG(INTC_MIR1
, 0x00a4);
80 DUMP_INTC_REG(INTC_MIR2
, 0x00c4);
83 DUMP_CM_MOD_REG(CORE_MOD
, CM_FCLKEN1
);
84 if (cpu_is_omap24xx()) {
85 DUMP_CM_MOD_REG(CORE_MOD
, OMAP24XX_CM_FCLKEN2
);
86 DUMP_PRM_MOD_REG(OMAP24XX_GR_MOD
,
87 OMAP2_PRCM_CLKEMUL_CTRL_OFFSET
);
88 DUMP_PRM_MOD_REG(OMAP24XX_GR_MOD
,
89 OMAP2_PRCM_CLKSRC_CTRL_OFFSET
);
91 DUMP_CM_MOD_REG(WKUP_MOD
, CM_FCLKEN
);
92 DUMP_CM_MOD_REG(CORE_MOD
, CM_ICLKEN1
);
93 DUMP_CM_MOD_REG(CORE_MOD
, CM_ICLKEN2
);
94 DUMP_CM_MOD_REG(WKUP_MOD
, CM_ICLKEN
);
95 DUMP_CM_MOD_REG(PLL_MOD
, CM_CLKEN
);
96 DUMP_CM_MOD_REG(PLL_MOD
, CM_AUTOIDLE
);
97 DUMP_PRM_MOD_REG(CORE_MOD
, OMAP2_PM_PWSTST
);
101 if (cpu_is_omap24xx()) {
102 DUMP_CM_MOD_REG(OMAP24XX_DSP_MOD
, CM_FCLKEN
);
103 DUMP_CM_MOD_REG(OMAP24XX_DSP_MOD
, CM_ICLKEN
);
104 DUMP_CM_MOD_REG(OMAP24XX_DSP_MOD
, CM_IDLEST
);
105 DUMP_CM_MOD_REG(OMAP24XX_DSP_MOD
, CM_AUTOIDLE
);
106 DUMP_CM_MOD_REG(OMAP24XX_DSP_MOD
, CM_CLKSEL
);
107 DUMP_CM_MOD_REG(OMAP24XX_DSP_MOD
, OMAP2_CM_CLKSTCTRL
);
108 DUMP_PRM_MOD_REG(OMAP24XX_DSP_MOD
, OMAP2_RM_RSTCTRL
);
109 DUMP_PRM_MOD_REG(OMAP24XX_DSP_MOD
, OMAP2_RM_RSTST
);
110 DUMP_PRM_MOD_REG(OMAP24XX_DSP_MOD
, OMAP2_PM_PWSTCTRL
);
111 DUMP_PRM_MOD_REG(OMAP24XX_DSP_MOD
, OMAP2_PM_PWSTST
);
115 DUMP_PRM_MOD_REG(CORE_MOD
, PM_WKST1
);
116 if (cpu_is_omap24xx())
117 DUMP_PRM_MOD_REG(CORE_MOD
, OMAP24XX_PM_WKST2
);
118 DUMP_PRM_MOD_REG(WKUP_MOD
, PM_WKST
);
119 DUMP_PRM_MOD_REG(OCP_MOD
, OMAP2_PRCM_IRQSTATUS_MPU_OFFSET
);
121 DUMP_INTC_REG(INTC_PENDING_IRQ0
, 0x0098);
122 DUMP_INTC_REG(INTC_PENDING_IRQ1
, 0x00b8);
123 DUMP_INTC_REG(INTC_PENDING_IRQ2
, 0x00d8);
145 "--- Going to %s %s (next timer after %u ms)\n", s1
, s2
,
146 jiffies_to_msecs(get_next_timer_interrupt(jiffies
) -
149 printk(KERN_INFO
"--- Going to %s %s\n", s1
, s2
);
152 printk(KERN_INFO
"--- Woke up (slept for %u.%03u ms)\n",
153 us
/ 1000, us
% 1000);
155 for (i
= 0; i
< reg_count
; i
++)
156 printk(KERN_INFO
"%-20s: 0x%08x\n", regs
[i
].name
, regs
[i
].val
);
159 #ifdef CONFIG_DEBUG_FS
160 #include <linux/debugfs.h>
161 #include <linux/seq_file.h>
163 static void pm_dbg_regset_store(u32
*ptr
);
165 struct dentry
*pm_dbg_dir
;
167 static int pm_dbg_init_done
;
169 static int __init
pm_dbg_init(void);
172 DEBUG_FILE_COUNTERS
= 0,
176 struct pm_module_def
{
177 char name
[8]; /* Name of the module */
178 short type
; /* CM or PRM */
179 unsigned short offset
;
180 int low
; /* First register address on this module */
181 int high
; /* Last register address on this module */
187 static const struct pm_module_def
*pm_dbg_reg_modules
;
188 static const struct pm_module_def omap3_pm_reg_modules
[] = {
189 { "IVA2", MOD_CM
, OMAP3430_IVA2_MOD
, 0, 0x4c },
190 { "OCP", MOD_CM
, OCP_MOD
, 0, 0x10 },
191 { "MPU", MOD_CM
, MPU_MOD
, 4, 0x4c },
192 { "CORE", MOD_CM
, CORE_MOD
, 0, 0x4c },
193 { "SGX", MOD_CM
, OMAP3430ES2_SGX_MOD
, 0, 0x4c },
194 { "WKUP", MOD_CM
, WKUP_MOD
, 0, 0x40 },
195 { "CCR", MOD_CM
, PLL_MOD
, 0, 0x70 },
196 { "DSS", MOD_CM
, OMAP3430_DSS_MOD
, 0, 0x4c },
197 { "CAM", MOD_CM
, OMAP3430_CAM_MOD
, 0, 0x4c },
198 { "PER", MOD_CM
, OMAP3430_PER_MOD
, 0, 0x4c },
199 { "EMU", MOD_CM
, OMAP3430_EMU_MOD
, 0x40, 0x54 },
200 { "NEON", MOD_CM
, OMAP3430_NEON_MOD
, 0x20, 0x48 },
201 { "USB", MOD_CM
, OMAP3430ES2_USBHOST_MOD
, 0, 0x4c },
203 { "IVA2", MOD_PRM
, OMAP3430_IVA2_MOD
, 0x50, 0xfc },
204 { "OCP", MOD_PRM
, OCP_MOD
, 4, 0x1c },
205 { "MPU", MOD_PRM
, MPU_MOD
, 0x58, 0xe8 },
206 { "CORE", MOD_PRM
, CORE_MOD
, 0x58, 0xf8 },
207 { "SGX", MOD_PRM
, OMAP3430ES2_SGX_MOD
, 0x58, 0xe8 },
208 { "WKUP", MOD_PRM
, WKUP_MOD
, 0xa0, 0xb0 },
209 { "CCR", MOD_PRM
, PLL_MOD
, 0x40, 0x70 },
210 { "DSS", MOD_PRM
, OMAP3430_DSS_MOD
, 0x58, 0xe8 },
211 { "CAM", MOD_PRM
, OMAP3430_CAM_MOD
, 0x58, 0xe8 },
212 { "PER", MOD_PRM
, OMAP3430_PER_MOD
, 0x58, 0xe8 },
213 { "EMU", MOD_PRM
, OMAP3430_EMU_MOD
, 0x58, 0xe4 },
214 { "GLBL", MOD_PRM
, OMAP3430_GR_MOD
, 0x20, 0xe4 },
215 { "NEON", MOD_PRM
, OMAP3430_NEON_MOD
, 0x58, 0xe8 },
216 { "USB", MOD_PRM
, OMAP3430ES2_USBHOST_MOD
, 0x58, 0xe8 },
220 #define PM_DBG_MAX_REG_SETS 4
222 static void *pm_dbg_reg_set
[PM_DBG_MAX_REG_SETS
];
224 static int pm_dbg_get_regset_size(void)
226 static int regset_size
;
228 if (regset_size
== 0) {
231 while (pm_dbg_reg_modules
[i
].name
[0] != 0) {
232 regset_size
+= pm_dbg_reg_modules
[i
].high
+
233 4 - pm_dbg_reg_modules
[i
].low
;
240 static int pm_dbg_show_regs(struct seq_file
*s
, void *unused
)
244 int reg_set
= (int)s
->private;
251 store
= kmalloc(pm_dbg_get_regset_size(), GFP_KERNEL
);
253 pm_dbg_regset_store(ptr
);
255 ptr
= pm_dbg_reg_set
[reg_set
- 1];
260 while (pm_dbg_reg_modules
[i
].name
[0] != 0) {
263 if (pm_dbg_reg_modules
[i
].type
== MOD_CM
)
264 seq_printf(s
, "MOD: CM_%s (%08x)\n",
265 pm_dbg_reg_modules
[i
].name
,
266 (u32
)(OMAP3430_CM_BASE
+
267 pm_dbg_reg_modules
[i
].offset
));
269 seq_printf(s
, "MOD: PRM_%s (%08x)\n",
270 pm_dbg_reg_modules
[i
].name
,
271 (u32
)(OMAP3430_PRM_BASE
+
272 pm_dbg_reg_modules
[i
].offset
));
274 for (j
= pm_dbg_reg_modules
[i
].low
;
275 j
<= pm_dbg_reg_modules
[i
].high
; j
+= 4) {
283 seq_printf(s
, " %02x => %08lx", j
, val
);
298 static void pm_dbg_regset_store(u32
*ptr
)
305 while (pm_dbg_reg_modules
[i
].name
[0] != 0) {
306 for (j
= pm_dbg_reg_modules
[i
].low
;
307 j
<= pm_dbg_reg_modules
[i
].high
; j
+= 4) {
308 if (pm_dbg_reg_modules
[i
].type
== MOD_CM
)
309 val
= cm_read_mod_reg(
310 pm_dbg_reg_modules
[i
].offset
, j
);
312 val
= prm_read_mod_reg(
313 pm_dbg_reg_modules
[i
].offset
, j
);
320 int pm_dbg_regset_save(int reg_set
)
322 if (pm_dbg_reg_set
[reg_set
-1] == NULL
)
325 pm_dbg_regset_store(pm_dbg_reg_set
[reg_set
-1]);
330 static const char pwrdm_state_names
[][PWRDM_MAX_PWRSTS
] = {
337 void pm_dbg_update_time(struct powerdomain
*pwrdm
, int prev
)
341 if (!pm_dbg_init_done
)
344 /* Update timer for previous state */
347 pwrdm
->state_timer
[prev
] += t
- pwrdm
->timer
;
352 static int clkdm_dbg_show_counter(struct clockdomain
*clkdm
, void *user
)
354 struct seq_file
*s
= (struct seq_file
*)user
;
356 if (strcmp(clkdm
->name
, "emu_clkdm") == 0 ||
357 strcmp(clkdm
->name
, "wkup_clkdm") == 0 ||
358 strncmp(clkdm
->name
, "dpll", 4) == 0)
361 seq_printf(s
, "%s->%s (%d)", clkdm
->name
,
362 clkdm
->pwrdm
.ptr
->name
,
363 atomic_read(&clkdm
->usecount
));
369 static int pwrdm_dbg_show_counter(struct powerdomain
*pwrdm
, void *user
)
371 struct seq_file
*s
= (struct seq_file
*)user
;
374 if (strcmp(pwrdm
->name
, "emu_pwrdm") == 0 ||
375 strcmp(pwrdm
->name
, "wkup_pwrdm") == 0 ||
376 strncmp(pwrdm
->name
, "dpll", 4) == 0)
379 if (pwrdm
->state
!= pwrdm_read_pwrst(pwrdm
))
380 printk(KERN_ERR
"pwrdm state mismatch(%s) %d != %d\n",
381 pwrdm
->name
, pwrdm
->state
, pwrdm_read_pwrst(pwrdm
));
383 seq_printf(s
, "%s (%s)", pwrdm
->name
,
384 pwrdm_state_names
[pwrdm
->state
]);
385 for (i
= 0; i
< PWRDM_MAX_PWRSTS
; i
++)
386 seq_printf(s
, ",%s:%d", pwrdm_state_names
[i
],
387 pwrdm
->state_counter
[i
]);
389 seq_printf(s
, ",RET-LOGIC-OFF:%d", pwrdm
->ret_logic_off_counter
);
390 for (i
= 0; i
< pwrdm
->banks
; i
++)
391 seq_printf(s
, ",RET-MEMBANK%d-OFF:%d", i
+ 1,
392 pwrdm
->ret_mem_off_counter
[i
]);
399 static int pwrdm_dbg_show_timer(struct powerdomain
*pwrdm
, void *user
)
401 struct seq_file
*s
= (struct seq_file
*)user
;
404 if (strcmp(pwrdm
->name
, "emu_pwrdm") == 0 ||
405 strcmp(pwrdm
->name
, "wkup_pwrdm") == 0 ||
406 strncmp(pwrdm
->name
, "dpll", 4) == 0)
409 pwrdm_state_switch(pwrdm
);
411 seq_printf(s
, "%s (%s)", pwrdm
->name
,
412 pwrdm_state_names
[pwrdm
->state
]);
414 for (i
= 0; i
< 4; i
++)
415 seq_printf(s
, ",%s:%lld", pwrdm_state_names
[i
],
416 pwrdm
->state_timer
[i
]);
422 static int pm_dbg_show_counters(struct seq_file
*s
, void *unused
)
424 pwrdm_for_each(pwrdm_dbg_show_counter
, s
);
425 clkdm_for_each(clkdm_dbg_show_counter
, s
);
430 static int pm_dbg_show_timers(struct seq_file
*s
, void *unused
)
432 pwrdm_for_each(pwrdm_dbg_show_timer
, s
);
436 static int pm_dbg_open(struct inode
*inode
, struct file
*file
)
438 switch ((int)inode
->i_private
) {
439 case DEBUG_FILE_COUNTERS
:
440 return single_open(file
, pm_dbg_show_counters
,
442 case DEBUG_FILE_TIMERS
:
444 return single_open(file
, pm_dbg_show_timers
,
449 static int pm_dbg_reg_open(struct inode
*inode
, struct file
*file
)
451 return single_open(file
, pm_dbg_show_regs
, inode
->i_private
);
454 static const struct file_operations debug_fops
= {
458 .release
= single_release
,
461 static const struct file_operations debug_reg_fops
= {
462 .open
= pm_dbg_reg_open
,
465 .release
= single_release
,
468 int pm_dbg_regset_init(int reg_set
)
472 if (!pm_dbg_init_done
)
475 if (reg_set
< 1 || reg_set
> PM_DBG_MAX_REG_SETS
||
476 pm_dbg_reg_set
[reg_set
-1] != NULL
)
479 pm_dbg_reg_set
[reg_set
-1] =
480 kmalloc(pm_dbg_get_regset_size(), GFP_KERNEL
);
482 if (pm_dbg_reg_set
[reg_set
-1] == NULL
)
485 if (pm_dbg_dir
!= NULL
) {
486 sprintf(name
, "%d", reg_set
);
488 (void) debugfs_create_file(name
, S_IRUGO
,
489 pm_dbg_dir
, (void *)reg_set
, &debug_reg_fops
);
495 static int pwrdm_suspend_get(void *data
, u64
*val
)
498 ret
= omap3_pm_get_suspend_state((struct powerdomain
*)data
);
506 static int pwrdm_suspend_set(void *data
, u64 val
)
508 return omap3_pm_set_suspend_state((struct powerdomain
*)data
, (int)val
);
511 DEFINE_SIMPLE_ATTRIBUTE(pwrdm_suspend_fops
, pwrdm_suspend_get
,
512 pwrdm_suspend_set
, "%llu\n");
514 static int __init
pwrdms_setup(struct powerdomain
*pwrdm
, void *dir
)
522 for (i
= 0; i
< 4; i
++)
523 pwrdm
->state_timer
[i
] = 0;
527 if (strncmp(pwrdm
->name
, "dpll", 4) == 0)
530 d
= debugfs_create_dir(pwrdm
->name
, (struct dentry
*)dir
);
532 (void) debugfs_create_file("suspend", S_IRUGO
|S_IWUSR
, d
,
533 (void *)pwrdm
, &pwrdm_suspend_fops
);
538 static int option_get(void *data
, u64
*val
)
547 static int option_set(void *data
, u64 val
)
553 if (option
== &enable_off_mode
)
554 omap3_pm_off_mode_enable(val
);
559 DEFINE_SIMPLE_ATTRIBUTE(pm_dbg_option_fops
, option_get
, option_set
, "%llu\n");
561 static int __init
pm_dbg_init(void)
567 if (pm_dbg_init_done
)
570 if (cpu_is_omap34xx())
571 pm_dbg_reg_modules
= omap3_pm_reg_modules
;
573 printk(KERN_ERR
"%s: only OMAP3 supported\n", __func__
);
577 d
= debugfs_create_dir("pm_debug", NULL
);
581 (void) debugfs_create_file("count", S_IRUGO
,
582 d
, (void *)DEBUG_FILE_COUNTERS
, &debug_fops
);
583 (void) debugfs_create_file("time", S_IRUGO
,
584 d
, (void *)DEBUG_FILE_TIMERS
, &debug_fops
);
586 pwrdm_for_each(pwrdms_setup
, (void *)d
);
588 pm_dbg_dir
= debugfs_create_dir("registers", d
);
589 if (IS_ERR(pm_dbg_dir
))
590 return PTR_ERR(pm_dbg_dir
);
592 (void) debugfs_create_file("current", S_IRUGO
,
593 pm_dbg_dir
, (void *)0, &debug_reg_fops
);
595 for (i
= 0; i
< PM_DBG_MAX_REG_SETS
; i
++)
596 if (pm_dbg_reg_set
[i
] != NULL
) {
597 sprintf(name
, "%d", i
+1);
598 (void) debugfs_create_file(name
, S_IRUGO
,
599 pm_dbg_dir
, (void *)(i
+1), &debug_reg_fops
);
603 (void) debugfs_create_file("enable_off_mode", S_IRUGO
| S_IWUGO
, d
,
604 &enable_off_mode
, &pm_dbg_option_fops
);
605 (void) debugfs_create_file("sleep_while_idle", S_IRUGO
| S_IWUGO
, d
,
606 &sleep_while_idle
, &pm_dbg_option_fops
);
607 (void) debugfs_create_file("wakeup_timer_seconds", S_IRUGO
| S_IWUGO
, d
,
608 &wakeup_timer_seconds
, &pm_dbg_option_fops
);
609 pm_dbg_init_done
= 1;
613 arch_initcall(pm_dbg_init
);