| /* |
| * Copyright (C) 2014 Motorola Mobility LLC |
| * |
| * This software is licensed under the terms of the GNU General Public |
| * License version 2, as published by the Free Software Foundation, and |
| * may be copied, distributed, and modified under those terms. |
| * |
| * This program is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| * GNU General Public License for more details. |
| * |
| * Work based on OMAP Power Management debug routines |
| * Copyright (C) 2005 Texas Instruments, Inc. |
| * Copyright (C) 2006-2008 Nokia Corporation |
| * |
| * Written by: |
| * Richard Woodruff <r-woodruff2@ti.com> |
| * Tony Lindgren |
| * Juha Yrjola |
| * Amit Kucheria <amit.kucheria@nokia.com> |
| * Igor Stoppa <igor.stoppa@nokia.com> |
| * Jouni Hogander |
| */ |
| |
| #include <linux/kernel.h> |
| #include <linux/sched.h> |
| #include <linux/clk.h> |
| #include <linux/err.h> |
| #include <linux/io.h> |
| #include <linux/module.h> |
| #include <linux/slab.h> |
| |
| #include "iomap.h" |
| #include "clock.h" |
| #include "powerdomain.h" |
| #include "clockdomain.h" |
| #include "omap-pm.h" |
| |
| #include "soc.h" |
| #include "cm2xxx_3xxx.h" |
| #include "prm3xxx.h" |
| #include "prm2xxx_3xxx.h" |
| #include "pm.h" |
| |
| #ifdef CONFIG_DEBUG_FS |
| #include <linux/debugfs.h> |
| #include <linux/seq_file.h> |
| |
| static struct dentry *pm_dbg_dir; |
| #endif |
| |
| struct pm_module_def { |
| char name[8]; /* Name of the module */ |
| short type; /* CM or PRM */ |
| unsigned short offset; |
| int low; /* First register address on this module */ |
| int high; /* Last register address on this module */ |
| }; |
| |
| #define MOD_CM 0 |
| #define MOD_PRM 1 |
| |
| |
| static const struct pm_module_def pm_dbg_reg_modules[] = { |
| { "IVA2", MOD_CM, OMAP3430_IVA2_MOD, 0, 0x4c }, |
| { "OCP", MOD_CM, OCP_MOD, 0, 0x10 }, |
| { "MPU", MOD_CM, MPU_MOD, 4, 0x4c }, |
| { "CORE", MOD_CM, CORE_MOD, 0, 0x4c }, |
| { "SGX", MOD_CM, OMAP3430ES2_SGX_MOD, 0, 0x4c }, |
| { "WKUP", MOD_CM, WKUP_MOD, 0, 0x40 }, |
| { "CCR", MOD_CM, PLL_MOD, 0, 0x70 }, |
| { "DSS", MOD_CM, OMAP3430_DSS_MOD, 0, 0x4c }, |
| { "CAM", MOD_CM, OMAP3430_CAM_MOD, 0, 0x4c }, |
| { "PER", MOD_CM, OMAP3430_PER_MOD, 0, 0x4c }, |
| { "EMU", MOD_CM, OMAP3430_EMU_MOD, 0x40, 0x54 }, |
| { "NEON", MOD_CM, OMAP3430_NEON_MOD, 0x20, 0x48 }, |
| { "USB", MOD_CM, OMAP3430ES2_USBHOST_MOD, 0, 0x4c }, |
| |
| { "IVA2", MOD_PRM, OMAP3430_IVA2_MOD, 0x50, 0xfc }, |
| { "OCP", MOD_PRM, OCP_MOD, 4, 0x1c }, |
| { "MPU", MOD_PRM, MPU_MOD, 0x58, 0xe8 }, |
| { "CORE", MOD_PRM, CORE_MOD, 0x58, 0xf8 }, |
| { "SGX", MOD_PRM, OMAP3430ES2_SGX_MOD, 0x58, 0xe8 }, |
| { "WKUP", MOD_PRM, WKUP_MOD, 0xa0, 0xb0 }, |
| { "CCR", MOD_PRM, PLL_MOD, 0x40, 0x70 }, |
| { "DSS", MOD_PRM, OMAP3430_DSS_MOD, 0x58, 0xe8 }, |
| { "CAM", MOD_PRM, OMAP3430_CAM_MOD, 0x58, 0xe8 }, |
| { "PER", MOD_PRM, OMAP3430_PER_MOD, 0x58, 0xe8 }, |
| { "EMU", MOD_PRM, OMAP3430_EMU_MOD, 0x58, 0xe4 }, |
| { "GLBL", MOD_PRM, OMAP3430_GR_MOD, 0x20, 0xe4 }, |
| { "NEON", MOD_PRM, OMAP3430_NEON_MOD, 0x58, 0xe8 }, |
| { "USB", MOD_PRM, OMAP3430ES2_USBHOST_MOD, 0x58, 0xe8 }, |
| { "", 0, 0, 0, 0 }, |
| }; |
| |
| #define PM_DBG_MAX_REG_SETS 4 |
| |
| static void *pm_dbg_reg_set[PM_DBG_MAX_REG_SETS] = {0}; |
| |
| static int pm_dbg_get_regset_size(void) |
| { |
| static int regset_size = 0; |
| |
| if (regset_size == 0) { |
| int i = 0; |
| while (pm_dbg_reg_modules[i].name[0] != 0) { |
| regset_size += pm_dbg_reg_modules[i].high + |
| 4 - pm_dbg_reg_modules[i].low; |
| i++; |
| } |
| } |
| return regset_size; |
| } |
| |
| static void pm_dbg_regset_store(u32 *ptr) |
| { |
| int i = 0; |
| int j; |
| u32 val; |
| |
| while (pm_dbg_reg_modules[i].name[0] != 0) { |
| for (j = pm_dbg_reg_modules[i].low; |
| j <= pm_dbg_reg_modules[i].high; j += 4) { |
| if (pm_dbg_reg_modules[i].type == MOD_CM) |
| val = omap2_cm_read_mod_reg( |
| pm_dbg_reg_modules[i].offset, j); |
| else |
| val = omap2_prm_read_mod_reg( |
| pm_dbg_reg_modules[i].offset, j); |
| *(ptr++) = val; |
| } |
| i++; |
| } |
| } |
| |
| void pm_dbg_regs_copy(int tgt, int src) |
| { |
| size_t sz = pm_dbg_get_regset_size(); |
| |
| pr_debug("saved reference copy %s(%d, %d) size = %u <- %pS\n", |
| __func__, tgt, src, sz, __builtin_return_address(0)); |
| memcpy(pm_dbg_reg_set[tgt - 1], pm_dbg_reg_set[src - 1], sz); |
| } |
| |
| void pm_dbg_regs_save(int reg_set) |
| { |
| if (pm_dbg_reg_set[reg_set - 1] == NULL) |
| return; |
| |
| pm_dbg_regset_store(pm_dbg_reg_set[reg_set - 1]); |
| } |
| |
| #ifdef CONFIG_DEBUG_FS |
| static int pm_dbg_show_regs(struct seq_file *s, void *unused) |
| { |
| int i, j; |
| unsigned long val; |
| int reg_set = (int)s->private; |
| u32 *ptr; |
| void *store = NULL; |
| int regs; |
| int linefeed; |
| |
| if (!cpu_is_omap34xx()) |
| return -EINVAL; |
| |
| if (reg_set == 0) { |
| store = kmalloc(pm_dbg_get_regset_size(), GFP_KERNEL); |
| if (store == NULL) |
| return -ENOMEM; |
| ptr = store; |
| pm_dbg_regset_store(ptr); |
| } else { |
| ptr = pm_dbg_reg_set[reg_set - 1]; |
| } |
| |
| i = 0; |
| |
| while (pm_dbg_reg_modules[i].name[0] != 0) { |
| regs = 0; |
| linefeed = 0; |
| if (pm_dbg_reg_modules[i].type == MOD_CM) |
| seq_printf(s, "MOD: CM_%s (%08x)\n", |
| pm_dbg_reg_modules[i].name, |
| (u32)(OMAP3430_CM_BASE + |
| pm_dbg_reg_modules[i].offset)); |
| else |
| seq_printf(s, "MOD: PRM_%s (%08x)\n", |
| pm_dbg_reg_modules[i].name, |
| (u32)(OMAP3430_PRM_BASE + |
| pm_dbg_reg_modules[i].offset)); |
| |
| for (j = pm_dbg_reg_modules[i].low; |
| j <= pm_dbg_reg_modules[i].high; j += 4) { |
| val = *(ptr++); |
| if (val != 0) { |
| regs++; |
| if (linefeed) { |
| seq_printf(s, "\n"); |
| linefeed = 0; |
| } |
| seq_printf(s, " %02x => %08lx", j, val); |
| if (regs % 4 == 0) |
| linefeed = 1; |
| } |
| } |
| seq_printf(s, "\n"); |
| i++; |
| } |
| |
| if (store != NULL) |
| kfree(store); |
| |
| return 0; |
| } |
| |
| #define WAKEUP_SOURCE_LEN 512 |
| void pm_dbg_show_wakeup_source(void) |
| { |
| u32 val = 0; |
| int len = 0; |
| static char buf[WAKEUP_SOURCE_LEN]; |
| char *pbuf; |
| u32 gpio_bit = 0; |
| |
| /* print the real wkup sources */ |
| memset(buf, 0, WAKEUP_SOURCE_LEN); |
| pbuf = buf; |
| len = WAKEUP_SOURCE_LEN - (pbuf - buf); |
| if (len > 16) |
| pbuf += snprintf(pbuf, len, "WAKEDUP BY: "); |
| |
| val = omap2_prm_read_mod_reg(WKUP_MOD, PM_WKST); |
| val &= omap2_prm_read_mod_reg(WKUP_MOD, PM_WKEN); |
| len = WAKEUP_SOURCE_LEN - (pbuf - buf); |
| if (val && len > 30) |
| pbuf += snprintf(pbuf, len, "WKUP_MOD(0x%x), ", val); |
| |
| val = omap2_prm_read_mod_reg(CORE_MOD, PM_WKST1); |
| val &= omap2_prm_read_mod_reg(CORE_MOD, PM_WKEN1); |
| len = WAKEUP_SOURCE_LEN - (pbuf - buf); |
| if (val && len > 30) |
| pbuf += snprintf(pbuf, len, "CORE_MOD(0x%x), ", val); |
| |
| val = omap2_prm_read_mod_reg(CORE_MOD, OMAP3430ES2_PM_WKST3); |
| val &= omap2_prm_read_mod_reg(CORE_MOD, OMAP3430ES2_PM_WKEN3); |
| len = WAKEUP_SOURCE_LEN - (pbuf - buf); |
| if (val && len > 30) |
| pbuf += snprintf(pbuf, len, "CORE3_MOD(0x%x), ", val); |
| |
| val = omap2_prm_read_mod_reg(OMAP3430_PER_MOD, PM_WKST); |
| val &= omap2_prm_read_mod_reg(OMAP3430_PER_MOD, PM_WKEN); |
| len = WAKEUP_SOURCE_LEN - (pbuf - buf); |
| if (val && len > 30) |
| pbuf += snprintf(pbuf, len, "PER_MOD(0x%x), ", val); |
| |
| val = omap2_prm_read_mod_reg(OMAP3430ES2_USBHOST_MOD, PM_WKST); |
| val &= omap2_prm_read_mod_reg(OMAP3430ES2_USBHOST_MOD, PM_WKEN); |
| len = WAKEUP_SOURCE_LEN - (pbuf - buf); |
| if (val && len > 30) |
| pbuf += snprintf(pbuf, len, "USBHOST(0x%x), ", val); |
| |
| val = omap2_prm_read_mod_reg(OMAP3430_DSS_MOD, PM_WKST); |
| val &= omap2_prm_read_mod_reg(OMAP3430_DSS_MOD, PM_WKEN); |
| len = WAKEUP_SOURCE_LEN - (pbuf - buf); |
| if (val && len > 30) |
| pbuf += snprintf(pbuf, len, "DSS(0x%x), ", val); |
| |
| val = omap2_prm_read_mod_reg(OCP_MOD, OMAP3_PRM_IRQSTATUS_MPU_OFFSET); |
| val &= omap2_prm_read_mod_reg(OCP_MOD, OMAP3_PRM_IRQENABLE_MPU_OFFSET); |
| len = WAKEUP_SOURCE_LEN - (pbuf - buf); |
| if (val && len > 30) |
| pbuf += snprintf(pbuf, len, "MPU_IRQSTATUS(0x%x), ", val); |
| |
| val = omap2_prm_read_mod_reg(OMAP3430_IVA2_MOD, OMAP3430_PRM_IRQSTATUS_IVA2); |
| val &= omap2_prm_read_mod_reg(OMAP3430_IVA2_MOD, OMAP3430_PRM_IRQENABLE_IVA2); |
| len = WAKEUP_SOURCE_LEN - (pbuf - buf); |
| if (val && len > 30) |
| pbuf += snprintf(pbuf, len, "IVA2_IRQSTATUS(0x%x), ", val); |
| |
| val = __raw_readl(OMAP2_L4_IO_ADDRESS(OMAP34XX_IC_BASE + (0x009C))); |
| len = WAKEUP_SOURCE_LEN - (pbuf - buf); |
| if (val && len > 30) |
| pbuf += snprintf(pbuf, len, "INTC_FIQ0(0x%x), ", val); |
| |
| val = __raw_readl(OMAP2_L4_IO_ADDRESS(OMAP34XX_IC_BASE + (0x00bC))); |
| len = WAKEUP_SOURCE_LEN - (pbuf - buf); |
| if (val && len > 30) |
| pbuf += snprintf(pbuf, len, "INTC_FIQ1(0x%x), ", val); |
| |
| val = __raw_readl(OMAP2_L4_IO_ADDRESS(OMAP34XX_IC_BASE + (0x00dC))); |
| len = WAKEUP_SOURCE_LEN - (pbuf - buf); |
| if (val && len > 30) |
| pbuf += snprintf(pbuf, len, "INTC_FIQ2(0x%x), ", val); |
| |
| |
| val = __raw_readl(OMAP2_L4_IO_ADDRESS(OMAP34XX_IC_BASE + (0x0098))); |
| len = WAKEUP_SOURCE_LEN - (pbuf - buf); |
| if (val && len > 30) |
| pbuf += snprintf(pbuf, len, "INTC_IRQ0(0x%x), ", val); |
| |
| val = __raw_readl(OMAP2_L4_IO_ADDRESS(OMAP34XX_IC_BASE + (0x00B8))); |
| len = WAKEUP_SOURCE_LEN - (pbuf - buf); |
| if (val && len > 30) |
| pbuf += snprintf(pbuf, len, "INTC_IRQ1(0x%x), ", val); |
| |
| val = __raw_readl(OMAP2_L4_IO_ADDRESS(OMAP34XX_IC_BASE + (0x00D8))); |
| len = WAKEUP_SOURCE_LEN - (pbuf - buf); |
| if (val && len > 30) |
| pbuf += snprintf(pbuf, len, "INTC_IRQ2(0x%x), ", val); |
| |
| val = __raw_readl(OMAP2_L4_IO_ADDRESS(OMAP34XX_IC_BASE + (0x009C))); |
| len = WAKEUP_SOURCE_LEN - (pbuf - buf); |
| if (val && len > 30) |
| pbuf += snprintf(pbuf, len, "INTC_FIQ0(0x%x), ", val); |
| |
| val = __raw_readl(OMAP2_L4_IO_ADDRESS(OMAP34XX_IC_BASE + (0x00BC))); |
| len = WAKEUP_SOURCE_LEN - (pbuf - buf); |
| if (val && len > 30) |
| pbuf += snprintf(pbuf, len, "INTC_FIQ1(0x%x), ", val); |
| |
| val = __raw_readl(OMAP2_L4_IO_ADDRESS(OMAP34XX_IC_BASE + (0x00DC))); |
| len = WAKEUP_SOURCE_LEN - (pbuf - buf); |
| if (val && len > 30) |
| pbuf += snprintf(pbuf, len, "INTC_FIQ2(0x%x), ", val); |
| |
| len = WAKEUP_SOURCE_LEN - (pbuf - buf); |
| if ((val & (1<<29)) && len > 20) { |
| gpio_bit = __raw_readl(OMAP2_L4_IO_ADDRESS(0x48310018)) & |
| __raw_readl(OMAP2_L4_IO_ADDRESS(0x4831001C)); |
| pbuf += snprintf(pbuf, len, "GPIO1(0x%x), ", gpio_bit); |
| } |
| len = WAKEUP_SOURCE_LEN - (pbuf - buf); |
| if ((val & (1<<30)) && len > 20) { |
| gpio_bit = __raw_readl(OMAP2_L4_IO_ADDRESS(0x49050018)) & |
| __raw_readl(OMAP2_L4_IO_ADDRESS(0x4905001C)); |
| pbuf += snprintf(pbuf, len, "GPIO2(0x%x), ", gpio_bit); |
| } |
| len = WAKEUP_SOURCE_LEN - (pbuf - buf); |
| if ((val & (1<<31)) && len > 20) { |
| gpio_bit = __raw_readl(OMAP2_L4_IO_ADDRESS(0x49052018)) & |
| __raw_readl(OMAP2_L4_IO_ADDRESS(0x4905201C)); |
| pbuf += snprintf(pbuf, len, "GPIO3(0x%x), ", gpio_bit); |
| } |
| |
| val = __raw_readl(OMAP2_L4_IO_ADDRESS(OMAP34XX_IC_BASE + (0x00b8))); |
| len = WAKEUP_SOURCE_LEN - (pbuf - buf); |
| if (val && len > 30) |
| pbuf += snprintf(pbuf, len, "INTC_IRQ1(0x%x), ", val); |
| |
| len = WAKEUP_SOURCE_LEN - (pbuf - buf); |
| if ((val & (1<<0)) && len > 20) { |
| gpio_bit = __raw_readl(OMAP2_L4_IO_ADDRESS(0x49054018)) & |
| __raw_readl(OMAP2_L4_IO_ADDRESS(0x4905401C)); |
| pbuf += snprintf(pbuf, len, "GPIO4(0x%x), ", gpio_bit); |
| } |
| len = WAKEUP_SOURCE_LEN - (pbuf - buf); |
| if ((val & (1<<1)) && len > 20) { |
| gpio_bit = __raw_readl(OMAP2_L4_IO_ADDRESS(0x49056018)) & |
| __raw_readl(OMAP2_L4_IO_ADDRESS(0x4905601C)); |
| pbuf += snprintf(pbuf, len, "GPIO5(0x%x), ", gpio_bit); |
| } |
| len = WAKEUP_SOURCE_LEN - (pbuf - buf); |
| if ((val & (1<<2)) && len > 20) { |
| gpio_bit = __raw_readl(OMAP2_L4_IO_ADDRESS(0x49058018)) & |
| __raw_readl(OMAP2_L4_IO_ADDRESS(0x4905801C)); |
| pbuf += snprintf(pbuf, len, "GPIO6(0x%x), ", gpio_bit); |
| } |
| |
| val = __raw_readl(OMAP2_L4_IO_ADDRESS(OMAP34XX_IC_BASE + (0x00d8))); |
| len = WAKEUP_SOURCE_LEN - (pbuf - buf); |
| if (val && len > 30) |
| pbuf += snprintf(pbuf, len, "INTC_IRQ2(0x%x)", val); |
| |
| pr_debug("%s\n", buf); |
| |
| } |
| EXPORT_SYMBOL(pm_dbg_show_wakeup_source); |
| |
| static int pm_dbg_reg_open(struct inode *inode, struct file *file) |
| { |
| return single_open(file, pm_dbg_show_regs, inode->i_private); |
| } |
| |
| static const struct file_operations debug_reg_fops = { |
| .open = pm_dbg_reg_open, |
| .read = seq_read, |
| .llseek = seq_lseek, |
| .release = single_release, |
| }; |
| #endif |
| |
| int pm_dbg_regs_dump(int reg_set) |
| { |
| int i, j; |
| unsigned long val; |
| u32 *ptr; |
| int regs; |
| |
| if ((reg_set <= 0) || (reg_set > PM_DBG_MAX_REG_SETS)) |
| return -EINVAL; |
| |
| ptr = pm_dbg_reg_set[reg_set - 1]; |
| |
| i = 0; |
| |
| while (pm_dbg_reg_modules[i].name[0] != 0) { |
| regs = 0; |
| if (pm_dbg_reg_modules[i].type == MOD_CM) |
| pr_debug("MOD: CM_%s (%08x)\n", |
| pm_dbg_reg_modules[i].name, |
| (u32)(OMAP3430_CM_BASE + |
| pm_dbg_reg_modules[i].offset)); |
| else |
| pr_debug("MOD: PRM_%s (%08x)\n", |
| pm_dbg_reg_modules[i].name, |
| (u32)(OMAP3430_PRM_BASE + |
| pm_dbg_reg_modules[i].offset)); |
| |
| for (j = pm_dbg_reg_modules[i].low; |
| j <= pm_dbg_reg_modules[i].high; j += 4) { |
| val = *(ptr++); |
| if (val != 0) { |
| regs++; |
| pr_debug(" %02x => %08lx\n", j, val); |
| } |
| } |
| i++; |
| } |
| |
| return 0; |
| } |
| EXPORT_SYMBOL(pm_dbg_regs_dump); |
| |
| int pm_dbg_regs_dump_delta(int cur, int ref) |
| { |
| int i, j; |
| unsigned long val_cur; |
| u32 *ptr_cur; |
| unsigned long val_ref; |
| u32 *ptr_ref; |
| |
| if ((cur <= 0) || (cur > PM_DBG_MAX_REG_SETS) || |
| (ref <= 0) || (ref > PM_DBG_MAX_REG_SETS)) { |
| return -EINVAL; |
| } |
| |
| ptr_cur = pm_dbg_reg_set[cur - 1]; |
| ptr_ref = pm_dbg_reg_set[ref - 1]; |
| |
| i = 0; |
| |
| pr_debug(" module ( address) reg %d %d\n", |
| cur, ref); |
| while (pm_dbg_reg_modules[i].name[0] != 0) { |
| bool cm = pm_dbg_reg_modules[i].type == MOD_CM; |
| u32 base_addr = cm ? OMAP3430_CM_BASE : OMAP3430_PRM_BASE; |
| |
| for (j = pm_dbg_reg_modules[i].low; |
| j <= pm_dbg_reg_modules[i].high; j += 4) { |
| u32 addr = (u32)(base_addr + pm_dbg_reg_modules[i].offset); |
| |
| val_cur = *(ptr_cur++); |
| val_ref = *(ptr_ref++); |
| if (val_cur != val_ref) { |
| pr_debug("MOD: %s_%-4s %s(%08x) " |
| "%02x => 0x%08lx 0x%08lx\n", |
| cm ? "CM" : "PRM", |
| pm_dbg_reg_modules[i].name, |
| cm ? " " : "", |
| addr, j, val_cur, val_ref); |
| } |
| } |
| i++; |
| } |
| return 0; |
| } |
| EXPORT_SYMBOL(pm_dbg_regs_dump_delta); |
| |
| static void __init pm_dbg_regset_init(void) |
| { |
| int i; |
| |
| for (i = 0; i < PM_DBG_MAX_REG_SETS; i++) { |
| pm_dbg_reg_set[i] = |
| kmalloc(pm_dbg_get_regset_size(), GFP_KERNEL); |
| } |
| } |
| |
| #ifdef CONFIG_DEBUG_FS |
| int __init pm_dbg_regs_init(struct dentry *d) |
| { |
| int i; |
| char name[2]; |
| |
| if (!cpu_is_omap34xx()) { |
| pr_err("%s: only OMAP3 supported\n", __func__); |
| return -ENODEV; |
| } |
| |
| pm_dbg_dir = debugfs_create_dir("registers", d); |
| if (IS_ERR(pm_dbg_dir)) |
| return PTR_ERR(pm_dbg_dir); |
| |
| (void) debugfs_create_file("current", S_IRUGO, |
| pm_dbg_dir, (void *)0, &debug_reg_fops); |
| |
| pm_dbg_regset_init(); |
| for (i = 0; i < PM_DBG_MAX_REG_SETS; i++) { |
| if (pm_dbg_reg_set[i] != NULL) { |
| sprintf(name, "%d", i + 1); |
| (void) debugfs_create_file(name, S_IRUGO, |
| pm_dbg_dir, (void *)(i+1), &debug_reg_fops); |
| } |
| } |
| |
| return 0; |
| } |
| #else |
| static int __init pm_dbg_regs_init(void) |
| { |
| if (!cpu_is_omap34xx()) { |
| pr_err("%s: only OMAP3 supported\n", __func__); |
| return -ENODEV; |
| } |
| |
| pm_dbg_regset_init(); |
| return 0; |
| } |
| omap_arch_initcall(pm_dbg_regs_init); |
| #endif |