soc: qcom: Add snapshot of SMEM_LOG Driver

This snapshot is taken as of msm-3.18 commit e70ad0cd (Promotion of
kernel.lnx.3.18-151201.)

Signed-off-by: Karthikeyan Ramasubramanian <kramasub@codeaurora.org>

3 files changed, 1045 insertions, 0 deletions

diff --git a/drivers/soc/qcom/Kconfig b/drivers/soc/qcom/Kconfig
index 7b2ec797a345..9250d74677e2 100644
--- a/drivers/soc/qcom/Kconfig
+++ b/drivers/soc/qcom/Kconfig
@@ -70,6 +70,15 @@ config MSM_GLINK_SMEM_NATIVE_XPRT
 	  transport to only connecting with entities internal to the
 	  System-on-Chip.
 
+config MSM_SMEM_LOGGING
+	depends on MSM_SMEM
+	bool "MSM Shared Memory Logger"
+	help
+	  Enable the shared memory logging to log the events between
+	  the various processors in the system. This option exposes
+	  the shared memory logger at /dev/smem_log and a debugfs node
+	  named smem_log.
+
 config MSM_SMP2P
 	bool "SMSM Point-to-Point (SMP2P)"
 	depends on MSM_SMEM
diff --git a/drivers/soc/qcom/Makefile b/drivers/soc/qcom/Makefile
index c806598098a1..4836a12dd434 100644
--- a/drivers/soc/qcom/Makefile
+++ b/drivers/soc/qcom/Makefile
@@ -4,6 +4,7 @@ obj-$(CONFIG_MSM_GLINK)	+=	glink.o glink_debugfs.o glink_ssr.o
 obj-$(CONFIG_MSM_GLINK_LOOPBACK_SERVER)	+=	glink_loopback_server.o
 obj-$(CONFIG_MSM_GLINK_SMD_XPRT)	+=	glink_smd_xprt.o
 obj-$(CONFIG_MSM_GLINK_SMEM_NATIVE_XPRT)+=	glink_smem_native_xprt.o
+obj-$(CONFIG_MSM_SMEM_LOGGING)	+=	smem_log.o
 obj-$(CONFIG_MSM_SYSMON_GLINK_COMM) += sysmon-glink.o sysmon-qmi.o
 obj-$(CONFIG_ARCH_QCOM) +=	kryo-l2-accessors.o
 obj-$(CONFIG_MSM_SMP2P)	+=	smp2p.o smp2p_debug.o smp2p_sleepstate.o
diff --git a/drivers/soc/qcom/smem_log.c b/drivers/soc/qcom/smem_log.c
new file mode 100644
index 000000000000..b5f8deb86aff
--- /dev/null
+++ b/drivers/soc/qcom/smem_log.c
@@ -0,0 +1,1035 @@
+/* Copyright (c) 2008-2014, The Linux Foundation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 and
+ * only version 2 as published by the Free Software Foundation.
+ *
+ * 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.
+ *
+ */
+/*
+ * Shared memory logging implementation.
+ */
+
+#include <linux/slab.h>
+#include <linux/uaccess.h>
+#include <linux/module.h>
+#include <linux/fs.h>
+#include <linux/miscdevice.h>
+#include <linux/kernel.h>
+#include <linux/errno.h>
+#include <linux/jiffies.h>
+#include <linux/remote_spinlock.h>
+#include <linux/debugfs.h>
+#include <linux/io.h>
+#include <linux/string.h>
+#include <linux/sched.h>
+#include <linux/wait.h>
+#include <linux/delay.h>
+
+#include <soc/qcom/smem.h>
+#include <soc/qcom/smem_log.h>
+
+#include <asm/arch_timer.h>
+
+#include "smem_private.h"
+
+#define DEBUG
+#undef DEBUG
+
+#ifdef DEBUG
+#define D_DUMP_BUFFER(prestr, cnt, buf) \
+do { \
+	int i; \
+	printk(KERN_ERR "%s", prestr); \
+	for (i = 0; i < cnt; i++) \
+		printk(KERN_ERR "%.2x", buf[i]); \
+	printk(KERN_ERR "\n"); \
+} while (0)
+#else
+#define D_DUMP_BUFFER(prestr, cnt, buf)
+#endif
+
+#ifdef DEBUG
+#define D(x...) printk(x)
+#else
+#define D(x...) do {} while (0)
+#endif
+
+struct smem_log_item {
+	uint32_t identifier;
+	uint32_t timetick;
+	uint32_t data1;
+	uint32_t data2;
+	uint32_t data3;
+};
+
+#define SMEM_LOG_NUM_ENTRIES 2000
+#define SMEM_LOG_EVENTS_SIZE (sizeof(struct smem_log_item) * \
+			      SMEM_LOG_NUM_ENTRIES)
+
+#define SMEM_SPINLOCK_SMEM_LOG		"S:2"
+
+static remote_spinlock_t remote_spinlock;
+static uint32_t smem_log_enable;
+static int smem_log_initialized;
+
+module_param_named(log_enable, smem_log_enable, int,
+		   S_IRUGO | S_IWUSR | S_IWGRP);
+
+
+struct smem_log_inst {
+	int which_log;
+	struct smem_log_item __iomem *events;
+	uint32_t __iomem *idx;
+	uint32_t num;
+	uint32_t read_idx;
+	uint32_t last_read_avail;
+	wait_queue_head_t read_wait;
+	remote_spinlock_t *remote_spinlock;
+};
+
+enum smem_logs {
+	GEN = 0,
+	NUM
+};
+
+static struct smem_log_inst inst[NUM];
+
+#if defined(CONFIG_DEBUG_FS)
+
+#define HSIZE 13
+
+struct sym {
+	uint32_t val;
+	char *str;
+	struct hlist_node node;
+};
+
+struct sym id_syms[] = {
+	{ SMEM_LOG_PROC_ID_MODEM, "MODM" },
+	{ SMEM_LOG_PROC_ID_Q6, "QDSP" },
+	{ SMEM_LOG_PROC_ID_APPS, "APPS" },
+	{ SMEM_LOG_PROC_ID_WCNSS, "WCNSS" },
+};
+
+struct sym base_syms[] = {
+	{ SMEM_LOG_SMEM_EVENT_BASE, "SMEM" },
+	{ SMEM_LOG_ERROR_EVENT_BASE, "ERROR" },
+	{ SMEM_LOG_QMI_CCI_EVENT_BASE, "QCCI" },
+	{ SMEM_LOG_QMI_CSI_EVENT_BASE, "QCSI" },
+};
+
+struct sym event_syms[] = {
+	{ ERR_ERROR_FATAL, "ERR_ERROR_FATAL" },
+	{ ERR_ERROR_FATAL_TASK, "ERR_ERROR_FATAL_TASK" },
+	{ SMEM_LOG_EVENT_CB, "CB" },
+	{ SMEM_LOG_EVENT_START, "START" },
+	{ SMEM_LOG_EVENT_INIT, "INIT" },
+	{ SMEM_LOG_EVENT_RUNNING, "RUNNING" },
+	{ SMEM_LOG_EVENT_STOP, "STOP" },
+	{ SMEM_LOG_EVENT_RESTART, "RESTART" },
+	{ SMEM_LOG_EVENT_SS, "SS" },
+	{ SMEM_LOG_EVENT_READ, "READ" },
+	{ SMEM_LOG_EVENT_WRITE, "WRITE" },
+	{ SMEM_LOG_EVENT_SIGS1, "SIGS1" },
+	{ SMEM_LOG_EVENT_SIGS2, "SIGS2" },
+	{ SMEM_LOG_EVENT_WRITE_DM, "WRITE_DM" },
+	{ SMEM_LOG_EVENT_READ_DM, "READ_DM" },
+	{ SMEM_LOG_EVENT_SKIP_DM, "SKIP_DM" },
+	{ SMEM_LOG_EVENT_STOP_DM, "STOP_DM" },
+	{ SMEM_LOG_EVENT_ISR, "ISR" },
+	{ SMEM_LOG_EVENT_TASK, "TASK" },
+	{ SMEM_LOG_EVENT_RS, "RS" },
+};
+
+struct sym smsm_syms[] = {
+	{ 0x80000000, "UN" },
+	{ 0x7F000000, "ERR" },
+	{ 0x00800000, "SMLP" },
+	{ 0x00400000, "ADWN" },
+	{ 0x00200000, "PWRS" },
+	{ 0x00100000, "DWLD" },
+	{ 0x00080000, "SRBT" },
+	{ 0x00040000, "SDWN" },
+	{ 0x00020000, "ARBT" },
+	{ 0x00010000, "REL" },
+	{ 0x00008000, "SLE" },
+	{ 0x00004000, "SLP" },
+	{ 0x00002000, "WFPI" },
+	{ 0x00001000, "EEX" },
+	{ 0x00000800, "TIN" },
+	{ 0x00000400, "TWT" },
+	{ 0x00000200, "PWRC" },
+	{ 0x00000100, "RUN" },
+	{ 0x00000080, "SA" },
+	{ 0x00000040, "RES" },
+	{ 0x00000020, "RIN" },
+	{ 0x00000010, "RWT" },
+	{ 0x00000008, "SIN" },
+	{ 0x00000004, "SWT" },
+	{ 0x00000002, "OE" },
+	{ 0x00000001, "I" },
+};
+
+struct sym smsm_entry_type_syms[] = {
+	{ 0, "SMSM_APPS_STATE" },
+	{ 1, "SMSM_MODEM_STATE" },
+	{ 2, "SMSM_Q6_STATE" },
+	{ 3, "SMSM_APPS_DEM" },
+	{ 4, "SMSM_MODEM_DEM" },
+	{ 5, "SMSM_Q6_DEM" },
+	{ 6, "SMSM_POWER_MASTER_DEM" },
+	{ 7, "SMSM_TIME_MASTER_DEM" },
+};
+
+struct sym smsm_state_syms[] = {
+	{ 0x00000001, "INIT" },
+	{ 0x00000002, "OSENTERED" },
+	{ 0x00000004, "SMDWAIT" },
+	{ 0x00000008, "SMDINIT" },
+	{ 0x00000010, "RPCWAIT" },
+	{ 0x00000020, "RPCINIT" },
+	{ 0x00000040, "RESET" },
+	{ 0x00000080, "RSA" },
+	{ 0x00000100, "RUN" },
+	{ 0x00000200, "PWRC" },
+	{ 0x00000400, "TIMEWAIT" },
+	{ 0x00000800, "TIMEINIT" },
+	{ 0x00001000, "PWRC_EARLY_EXIT" },
+	{ 0x00002000, "WFPI" },
+	{ 0x00004000, "SLEEP" },
+	{ 0x00008000, "SLEEPEXIT" },
+	{ 0x00010000, "OEMSBL_RELEASE" },
+	{ 0x00020000, "APPS_REBOOT" },
+	{ 0x00040000, "SYSTEM_POWER_DOWN" },
+	{ 0x00080000, "SYSTEM_REBOOT" },
+	{ 0x00100000, "SYSTEM_DOWNLOAD" },
+	{ 0x00200000, "PWRC_SUSPEND" },
+	{ 0x00400000, "APPS_SHUTDOWN" },
+	{ 0x00800000, "SMD_LOOPBACK" },
+	{ 0x01000000, "RUN_QUIET" },
+	{ 0x02000000, "MODEM_WAIT" },
+	{ 0x04000000, "MODEM_BREAK" },
+	{ 0x08000000, "MODEM_CONTINUE" },
+	{ 0x80000000, "UNKNOWN" },
+};
+
+enum sym_tables {
+	ID_SYM,
+	BASE_SYM,
+	EVENT_SYM,
+	SMSM_SYM,
+	SMSM_ENTRY_TYPE_SYM,
+	SMSM_STATE_SYM,
+};
+
+static struct sym_tbl {
+	struct sym *data;
+	int size;
+	struct hlist_head hlist[HSIZE];
+} tbl[] = {
+	{ id_syms, ARRAY_SIZE(id_syms) },
+	{ base_syms, ARRAY_SIZE(base_syms) },
+	{ event_syms, ARRAY_SIZE(event_syms) },
+	{ smsm_syms, ARRAY_SIZE(smsm_syms) },
+	{ smsm_entry_type_syms, ARRAY_SIZE(smsm_entry_type_syms) },
+	{ smsm_state_syms, ARRAY_SIZE(smsm_state_syms) },
+};
+
+#define hash(val) (val % HSIZE)
+
+static void init_syms(void)
+{
+	int i;
+	int j;
+
+	for (i = 0; i < ARRAY_SIZE(tbl); ++i)
+		for (j = 0; j < HSIZE; ++j)
+			INIT_HLIST_HEAD(&tbl[i].hlist[j]);
+
+	for (i = 0; i < ARRAY_SIZE(tbl); ++i)
+		for (j = 0; j < tbl[i].size; ++j) {
+			INIT_HLIST_NODE(&tbl[i].data[j].node);
+			hlist_add_head(&tbl[i].data[j].node,
+				       &tbl[i].hlist[hash(tbl[i].data[j].val)]);
+		}
+}
+
+static char *find_sym(uint32_t id, uint32_t val)
+{
+	struct hlist_node *n;
+	struct sym *s;
+
+	hlist_for_each(n, &tbl[id].hlist[hash(val)]) {
+		s = hlist_entry(n, struct sym, node);
+		if (s->val == val)
+			return s->str;
+	}
+
+	return 0;
+}
+
+#else
+static void init_syms(void) {}
+#endif
+
+union fifo_mem {
+	uint64_t u64;
+	uint8_t u8;
+};
+
+/**
+ * memcpy_to_log() - copy to SMEM log FIFO
+ * @dest: Destination address
+ * @src: Source address
+ * @num_bytes: Number of bytes to copy
+ *
+ * @return: Address of destination
+ *
+ * This function copies num_bytes from src to dest maintaining natural alignment
+ * for accesses to dest as required for Device memory.
+ */
+static void *memcpy_to_log(void *dest, const void *src, size_t num_bytes)
+{
+	union fifo_mem *temp_dst = (union fifo_mem *)dest;
+	union fifo_mem *temp_src = (union fifo_mem *)src;
+	uintptr_t mask = sizeof(union fifo_mem) - 1;
+
+	/* Do byte copies until we hit 8-byte (double word) alignment */
+	while ((uintptr_t)temp_dst & mask && num_bytes) {
+		__raw_writeb_no_log(temp_src->u8, temp_dst);
+		temp_src = (union fifo_mem *)((uintptr_t)temp_src + 1);
+		temp_dst = (union fifo_mem *)((uintptr_t)temp_dst + 1);
+		num_bytes--;
+	}
+
+	/* Do double word copies */
+	while (num_bytes >= sizeof(union fifo_mem)) {
+		__raw_writeq_no_log(temp_src->u64, temp_dst);
+		temp_dst++;
+		temp_src++;
+		num_bytes -= sizeof(union fifo_mem);
+	}
+
+	/* Copy remaining bytes */
+	while (num_bytes--) {
+		__raw_writeb_no_log(temp_src->u8, temp_dst);
+		temp_src = (union fifo_mem *)((uintptr_t)temp_src + 1);
+		temp_dst = (union fifo_mem *)((uintptr_t)temp_dst + 1);
+	}
+
+	return dest;
+}
+
+
+static inline unsigned int read_timestamp(void)
+{
+	return (unsigned int)(arch_counter_get_cntpct());
+}
+
+static void smem_log_event_from_user(struct smem_log_inst *inst,
+				     const char *buf, int size, int num)
+{
+	uint32_t idx;
+	uint32_t next_idx;
+	unsigned long flags;
+	uint32_t identifier = 0;
+	uint32_t timetick = 0;
+	int first = 1;
+
+	if (!inst->idx) {
+		pr_err("%s: invalid write index\n", __func__);
+		return;
+	}
+
+	remote_spin_lock_irqsave(inst->remote_spinlock, flags);
+
+	while (num--) {
+		idx = *inst->idx;
+
+		if (idx < inst->num) {
+			memcpy_to_log(&inst->events[idx], buf, size);
+
+			if (first) {
+				identifier =
+					inst->events[idx].
+					identifier;
+				timetick = read_timestamp();
+				first = 0;
+			} else {
+				identifier |= SMEM_LOG_CONT;
+			}
+			inst->events[idx].identifier =
+				identifier;
+			inst->events[idx].timetick =
+				timetick;
+		}
+
+		next_idx = idx + 1;
+		if (next_idx >= inst->num)
+			next_idx = 0;
+		*inst->idx = next_idx;
+		buf += sizeof(struct smem_log_item);
+	}
+
+	wmb();
+	remote_spin_unlock_irqrestore(inst->remote_spinlock, flags);
+}
+
+static void _smem_log_event(
+	struct smem_log_item __iomem *events,
+	uint32_t __iomem *_idx,
+	remote_spinlock_t *lock,
+	int num,
+	uint32_t id, uint32_t data1, uint32_t data2,
+	uint32_t data3)
+{
+	struct smem_log_item item;
+	uint32_t idx;
+	uint32_t next_idx;
+	unsigned long flags;
+
+	item.timetick = read_timestamp();
+	item.identifier = id;
+	item.data1 = data1;
+	item.data2 = data2;
+	item.data3 = data3;
+
+	remote_spin_lock_irqsave(lock, flags);
+
+	idx = *_idx;
+
+	if (idx < num)
+		memcpy_to_log(&events[idx], &item, sizeof(item));
+
+	next_idx = idx + 1;
+	if (next_idx >= num)
+		next_idx = 0;
+	*_idx = next_idx;
+	wmb();
+
+	remote_spin_unlock_irqrestore(lock, flags);
+}
+
+static void _smem_log_event6(
+	struct smem_log_item __iomem *events,
+	uint32_t __iomem *_idx,
+	remote_spinlock_t *lock,
+	int num,
+	uint32_t id, uint32_t data1, uint32_t data2,
+	uint32_t data3, uint32_t data4, uint32_t data5,
+	uint32_t data6)
+{
+	struct smem_log_item item[2];
+	uint32_t idx;
+	uint32_t next_idx;
+	unsigned long flags;
+
+	item[0].timetick = read_timestamp();
+	item[0].identifier = id;
+	item[0].data1 = data1;
+	item[0].data2 = data2;
+	item[0].data3 = data3;
+	item[1].identifier = item[0].identifier;
+	item[1].timetick = item[0].timetick;
+	item[1].data1 = data4;
+	item[1].data2 = data5;
+	item[1].data3 = data6;
+
+	remote_spin_lock_irqsave(lock, flags);
+
+	idx = *_idx;
+
+	/* FIXME: Wrap around */
+	if (idx < (num-1))
+		memcpy_to_log(&events[idx], &item, sizeof(item));
+
+	next_idx = idx + 2;
+	if (next_idx >= num)
+		next_idx = 0;
+	*_idx = next_idx;
+
+	wmb();
+	remote_spin_unlock_irqrestore(lock, flags);
+}
+
+void smem_log_event(uint32_t id, uint32_t data1, uint32_t data2,
+		    uint32_t data3)
+{
+	if (smem_log_enable)
+		_smem_log_event(inst[GEN].events, inst[GEN].idx,
+				inst[GEN].remote_spinlock,
+				SMEM_LOG_NUM_ENTRIES, id,
+				data1, data2, data3);
+}
+
+void smem_log_event6(uint32_t id, uint32_t data1, uint32_t data2,
+		     uint32_t data3, uint32_t data4, uint32_t data5,
+		     uint32_t data6)
+{
+	if (smem_log_enable)
+		_smem_log_event6(inst[GEN].events, inst[GEN].idx,
+				 inst[GEN].remote_spinlock,
+				 SMEM_LOG_NUM_ENTRIES, id,
+				 data1, data2, data3, data4, data5, data6);
+}
+
+static int _smem_log_init(void)
+{
+	int ret;
+
+	inst[GEN].which_log = GEN;
+	inst[GEN].events =
+		(struct smem_log_item *)smem_alloc(SMEM_SMEM_LOG_EVENTS,
+						  SMEM_LOG_EVENTS_SIZE,
+						  0,
+						  SMEM_ANY_HOST_FLAG);
+	inst[GEN].idx = (uint32_t *)smem_alloc(SMEM_SMEM_LOG_IDX,
+					     sizeof(uint32_t),
+					     0,
+					     SMEM_ANY_HOST_FLAG);
+	if (IS_ERR_OR_NULL(inst[GEN].events) || IS_ERR_OR_NULL(inst[GEN].idx)) {
+		pr_err("%s: no log or log_idx allocated\n", __func__);
+		return -ENODEV;
+	}
+
+	inst[GEN].num = SMEM_LOG_NUM_ENTRIES;
+	inst[GEN].read_idx = 0;
+	inst[GEN].last_read_avail = SMEM_LOG_NUM_ENTRIES;
+	init_waitqueue_head(&inst[GEN].read_wait);
+	inst[GEN].remote_spinlock = &remote_spinlock;
+
+	ret = remote_spin_lock_init(&remote_spinlock,
+			      SMEM_SPINLOCK_SMEM_LOG);
+	if (ret) {
+		mb();
+		return ret;
+	}
+
+	init_syms();
+	mb();
+
+	return 0;
+}
+
+static ssize_t smem_log_write_bin(struct file *fp, const char __user *_buf,
+			 size_t count, loff_t *pos)
+{
+	void *buf;
+	int r;
+
+	if (count < sizeof(struct smem_log_item))
+		return -EINVAL;
+
+	buf = kmalloc(count, GFP_KERNEL);
+	if (!buf)
+		return -ENOMEM;
+
+	r = copy_from_user(buf, _buf, count);
+	if (r) {
+		kfree(buf);
+		return -EFAULT;
+	}
+
+	if (smem_log_enable)
+		smem_log_event_from_user(fp->private_data, buf,
+					sizeof(struct smem_log_item),
+					count / sizeof(struct smem_log_item));
+	kfree(buf);
+	return count;
+}
+
+static int smem_log_open(struct inode *ip, struct file *fp)
+{
+	fp->private_data = &inst[GEN];
+
+	return 0;
+}
+
+static int smem_log_release(struct inode *ip, struct file *fp)
+{
+	return 0;
+}
+
+static const struct file_operations smem_log_bin_fops = {
+	.owner = THIS_MODULE,
+	.write = smem_log_write_bin,
+	.open = smem_log_open,
+	.release = smem_log_release,
+};
+
+static struct miscdevice smem_log_dev = {
+	.minor = MISC_DYNAMIC_MINOR,
+	.name = "smem_log",
+	.fops = &smem_log_bin_fops,
+};
+
+#if defined(CONFIG_DEBUG_FS)
+
+#define SMEM_LOG_ITEM_PRINT_SIZE 160
+
+#define EVENTS_PRINT_SIZE \
+(SMEM_LOG_ITEM_PRINT_SIZE * SMEM_LOG_NUM_ENTRIES)
+
+static uint32_t smem_log_timeout_ms;
+module_param_named(timeout_ms, smem_log_timeout_ms,
+		   int, S_IRUGO | S_IWUSR | S_IWGRP);
+
+static int smem_log_debug_mask;
+module_param_named(debug_mask, smem_log_debug_mask, int,
+		   S_IRUGO | S_IWUSR | S_IWGRP);
+
+#define DBG(x...) do {\
+	if (smem_log_debug_mask) \
+		printk(KERN_DEBUG x);\
+	} while (0)
+
+static int update_read_avail(struct smem_log_inst *inst)
+{
+	int curr_read_avail;
+	unsigned long flags = 0;
+
+	if (!inst->idx)
+		return 0;
+
+	remote_spin_lock_irqsave(inst->remote_spinlock, flags);
+	curr_read_avail = (*inst->idx - inst->read_idx);
+	if (curr_read_avail < 0)
+		curr_read_avail = inst->num - inst->read_idx + *inst->idx;
+
+	DBG("%s: read = %d write = %d curr = %d last = %d\n", __func__,
+	    inst->read_idx, *inst->idx, curr_read_avail, inst->last_read_avail);
+
+	if (curr_read_avail < inst->last_read_avail) {
+		if (inst->last_read_avail != inst->num)
+			pr_info("smem_log: skipping %d log entries\n",
+				inst->last_read_avail);
+		inst->read_idx = *inst->idx + 1;
+		inst->last_read_avail = inst->num - 1;
+	} else
+		inst->last_read_avail = curr_read_avail;
+
+	remote_spin_unlock_irqrestore(inst->remote_spinlock, flags);
+
+	DBG("%s: read = %d write = %d curr = %d last = %d\n", __func__,
+	    inst->read_idx, *inst->idx, curr_read_avail, inst->last_read_avail);
+
+	return inst->last_read_avail;
+}
+
+static int _debug_dump(int log, char *buf, int max, uint32_t cont)
+{
+	unsigned int idx;
+	int write_idx, read_avail = 0;
+	unsigned long flags;
+	int i = 0;
+
+	if (!inst[log].events)
+		return 0;
+
+	if (cont && update_read_avail(&inst[log]) == 0)
+		return 0;
+
+	remote_spin_lock_irqsave(inst[log].remote_spinlock, flags);
+
+	if (cont) {
+		idx = inst[log].read_idx;
+		write_idx = (inst[log].read_idx + inst[log].last_read_avail);
+		if (write_idx >= inst[log].num)
+			write_idx -= inst[log].num;
+	} else {
+		write_idx = *inst[log].idx;
+		idx = (write_idx + 1);
+	}
+
+	DBG("%s: read %d write %d idx %d num %d\n", __func__,
+	    inst[log].read_idx, write_idx, idx, inst[log].num - 1);
+
+	while ((max - i) > 50) {
+		if ((inst[log].num - 1) < idx)
+			idx = 0;
+
+		if (idx == write_idx)
+			break;
+
+		if (inst[log].events[idx].identifier) {
+
+			i += scnprintf(buf + i, max - i,
+				       "%08x %08x %08x %08x %08x\n",
+				       inst[log].events[idx].identifier,
+				       inst[log].events[idx].timetick,
+				       inst[log].events[idx].data1,
+				       inst[log].events[idx].data2,
+				       inst[log].events[idx].data3);
+		}
+		idx++;
+	}
+	if (cont) {
+		inst[log].read_idx = idx;
+		read_avail = (write_idx - inst[log].read_idx);
+		if (read_avail < 0)
+			read_avail = inst->num - inst->read_idx + write_idx;
+		inst[log].last_read_avail = read_avail;
+	}
+
+	remote_spin_unlock_irqrestore(inst[log].remote_spinlock, flags);
+
+	DBG("%s: read %d write %d idx %d num %d\n", __func__,
+	    inst[log].read_idx, write_idx, idx, inst[log].num);
+
+	return i;
+}
+
+static int _debug_dump_sym(int log, char *buf, int max, uint32_t cont)
+{
+	unsigned int idx;
+	int write_idx, read_avail = 0;
+	unsigned long flags;
+	int i = 0;
+
+	char *proc;
+	char *sub;
+	char *id;
+	const char *sym = NULL;
+
+	uint32_t proc_val = 0;
+	uint32_t sub_val = 0;
+	uint32_t id_val = 0;
+	uint32_t id_only_val = 0;
+	uint32_t data1 = 0;
+	uint32_t data2 = 0;
+	uint32_t data3 = 0;
+
+	if (!inst[log].events)
+		return 0;
+
+	if (cont && update_read_avail(&inst[log]) == 0)
+		return 0;
+
+	remote_spin_lock_irqsave(inst[log].remote_spinlock, flags);
+
+	if (cont) {
+		idx = inst[log].read_idx;
+		write_idx = (inst[log].read_idx + inst[log].last_read_avail);
+		if (write_idx >= inst[log].num)
+			write_idx -= inst[log].num;
+	} else {
+		write_idx = *inst[log].idx;
+		idx = (write_idx + 1);
+	}
+
+	DBG("%s: read %d write %d idx %d num %d\n", __func__,
+	    inst[log].read_idx, write_idx, idx, inst[log].num - 1);
+
+	for (; (max - i) > SMEM_LOG_ITEM_PRINT_SIZE; idx++) {
+		if (idx > (inst[log].num - 1))
+			idx = 0;
+
+		if (idx == write_idx)
+			break;
+
+		if (idx < inst[log].num) {
+			if (!inst[log].events[idx].identifier)
+				continue;
+
+			proc_val = PROC & inst[log].events[idx].identifier;
+			sub_val = SUB & inst[log].events[idx].identifier;
+			id_val = (SUB | ID) & inst[log].events[idx].identifier;
+			id_only_val = ID & inst[log].events[idx].identifier;
+			data1 = inst[log].events[idx].data1;
+			data2 = inst[log].events[idx].data2;
+			data3 = inst[log].events[idx].data3;
+
+			if (!(proc_val & SMEM_LOG_CONT)) {
+				i += scnprintf(buf + i, max - i, "\n");
+
+				proc = find_sym(ID_SYM, proc_val);
+
+				if (proc)
+					i += scnprintf(buf + i, max - i,
+						       "%4s: ", proc);
+				else
+					i += scnprintf(buf + i, max - i,
+						       "%04x: ",
+						       PROC &
+						       inst[log].events[idx].
+						       identifier);
+
+				i += scnprintf(buf + i, max - i, "%10u ",
+					       inst[log].events[idx].timetick);
+
+				sub = find_sym(BASE_SYM, sub_val);
+
+				if (sub)
+					i += scnprintf(buf + i, max - i,
+						       "%9s: ", sub);
+				else
+					i += scnprintf(buf + i, max - i,
+						       "%08x: ", sub_val);
+
+				id = find_sym(EVENT_SYM, id_val);
+
+				if (id)
+					i += scnprintf(buf + i, max - i,
+						       "%11s: ", id);
+				else
+					i += scnprintf(buf + i, max - i,
+						       "%08x: ", id_only_val);
+			}
+
+			if (proc_val & SMEM_LOG_CONT) {
+				i += scnprintf(buf + i, max - i,
+					       " %08x %08x %08x",
+					       data1, data2, data3);
+			} else if (id_val == SMEM_LOG_EVENT_CB) {
+				unsigned vals[] = {data2, data3};
+				unsigned j;
+				unsigned mask;
+				unsigned tmp;
+				unsigned once;
+				i += scnprintf(buf + i, max - i, "%08x ",
+					       data1);
+				for (j = 0; j < ARRAY_SIZE(vals); ++j) {
+					i += scnprintf(buf + i, max - i, "[");
+					mask = 0x80000000;
+					once = 0;
+					while (mask) {
+						tmp = vals[j] & mask;
+						mask >>= 1;
+						if (!tmp)
+							continue;
+						sym = find_sym(SMSM_SYM, tmp);
+
+						if (once)
+							i += scnprintf(buf + i,
+								       max - i,
+								       " ");
+						if (sym)
+							i += scnprintf(buf + i,
+								       max - i,
+								       "%s",
+								       sym);
+						else
+							i += scnprintf(buf + i,
+								       max - i,
+								       "%08x",
+								       tmp);
+						once = 1;
+					}
+					i += scnprintf(buf + i, max - i, "] ");
+				}
+			} else {
+				i += scnprintf(buf + i, max - i,
+					       "%08x %08x %08x",
+					       data1, data2, data3);
+			}
+		}
+	}
+	if (cont) {
+		inst[log].read_idx = idx;
+		read_avail = (write_idx - inst[log].read_idx);
+		if (read_avail < 0)
+			read_avail = inst->num - inst->read_idx + write_idx;
+		inst[log].last_read_avail = read_avail;
+	}
+
+	remote_spin_unlock_irqrestore(inst[log].remote_spinlock, flags);
+
+	DBG("%s: read %d write %d idx %d num %d\n", __func__,
+	    inst[log].read_idx, write_idx, idx, inst[log].num);
+
+	return i;
+}
+
+static int debug_dump(char *buf, int max, uint32_t cont)
+{
+	int r;
+
+	if (!inst[GEN].idx || !inst[GEN].events)
+		return -ENODEV;
+
+	while (cont) {
+		update_read_avail(&inst[GEN]);
+		r = wait_event_interruptible_timeout(inst[GEN].read_wait,
+						     inst[GEN].last_read_avail,
+						     smem_log_timeout_ms *
+						     HZ / 1000);
+		DBG("%s: read available %d\n", __func__,
+		    inst[GEN].last_read_avail);
+		if (r < 0)
+			return 0;
+		else if (inst[GEN].last_read_avail)
+			break;
+	}
+
+	return _debug_dump(GEN, buf, max, cont);
+}
+
+static int debug_dump_sym(char *buf, int max, uint32_t cont)
+{
+	int r;
+
+	if (!inst[GEN].idx || !inst[GEN].events)
+		return -ENODEV;
+
+	while (cont) {
+		update_read_avail(&inst[GEN]);
+		r = wait_event_interruptible_timeout(inst[GEN].read_wait,
+						     inst[GEN].last_read_avail,
+						     smem_log_timeout_ms *
+						     HZ / 1000);
+		DBG("%s: readavailable %d\n", __func__,
+		    inst[GEN].last_read_avail);
+		if (r < 0)
+			return 0;
+		else if (inst[GEN].last_read_avail)
+			break;
+	}
+
+	return _debug_dump_sym(GEN, buf, max, cont);
+}
+
+static char debug_buffer[EVENTS_PRINT_SIZE];
+
+static ssize_t debug_read(struct file *file, char __user *buf,
+			  size_t count, loff_t *ppos)
+{
+	int r;
+	int bsize = 0;
+	int (*fill)(char *, int, uint32_t) = file->private_data;
+	if (!(*ppos)) {
+		bsize = fill(debug_buffer, EVENTS_PRINT_SIZE, 0);
+
+		if (bsize < 0)
+			bsize = scnprintf(debug_buffer,
+				EVENTS_PRINT_SIZE, "Log not available\n");
+	}
+	DBG("%s: count %zu ppos %d\n", __func__, count, (unsigned int)*ppos);
+	r =  simple_read_from_buffer(buf, count, ppos, debug_buffer,
+				     bsize);
+	return r;
+}
+
+static ssize_t debug_read_cont(struct file *file, char __user *buf,
+			       size_t count, loff_t *ppos)
+{
+	int (*fill)(char *, int, uint32_t) = file->private_data;
+	char *buffer = kmalloc(count, GFP_KERNEL);
+	int bsize;
+	if (!buffer)
+		return -ENOMEM;
+
+	bsize = fill(buffer, count, 1);
+	if (bsize < 0) {
+		if (*ppos == 0)
+			bsize = scnprintf(buffer, count, "Log not available\n");
+		else
+			bsize = 0;
+	}
+
+	DBG("%s: count %zu bsize %d\n", __func__, count, bsize);
+	if (copy_to_user(buf, buffer, bsize)) {
+		kfree(buffer);
+		return -EFAULT;
+	}
+	*ppos += bsize;
+	kfree(buffer);
+	return bsize;
+}
+
+static int debug_open(struct inode *inode, struct file *file)
+{
+	file->private_data = inode->i_private;
+	return 0;
+}
+
+static const struct file_operations debug_ops = {
+	.read = debug_read,
+	.open = debug_open,
+};
+
+static const struct file_operations debug_ops_cont = {
+	.read = debug_read_cont,
+	.open = debug_open,
+};
+
+static void debug_create(const char *name, mode_t mode,
+			 struct dentry *dent,
+			 int (*fill)(char *buf, int max, uint32_t cont),
+			 const struct file_operations *fops)
+{
+	debugfs_create_file(name, mode, dent, fill, fops);
+}
+
+static void smem_log_debugfs_init(void)
+{
+	struct dentry *dent;
+
+	dent = debugfs_create_dir("smem_log", 0);
+	if (IS_ERR(dent))
+		return;
+
+	debug_create("dump", 0444, dent, debug_dump, &debug_ops);
+	debug_create("dump_sym", 0444, dent, debug_dump_sym, &debug_ops);
+
+	debug_create("dump_cont", 0444, dent, debug_dump, &debug_ops_cont);
+	debug_create("dump_sym_cont", 0444, dent,
+		     debug_dump_sym, &debug_ops_cont);
+
+	smem_log_timeout_ms = 500;
+	smem_log_debug_mask = 0;
+}
+#else
+static void smem_log_debugfs_init(void) {}
+#endif
+
+static int smem_log_initialize(void)
+{
+	int ret;
+
+	ret = _smem_log_init();
+	if (ret < 0) {
+		pr_err("%s: init failed %d\n", __func__, ret);
+		return ret;
+	}
+
+	ret = misc_register(&smem_log_dev);
+	if (ret < 0) {
+		pr_err("%s: device register failed %d\n", __func__, ret);
+		return ret;
+	}
+
+	smem_log_enable = 1;
+	smem_log_initialized = 1;
+	smem_log_debugfs_init();
+	return ret;
+}
+
+static int smem_module_init_notifier(struct notifier_block *this,
+				    unsigned long code,
+				    void *_cmd)
+{
+	int ret = 0;
+	if (!smem_log_initialized)
+		ret = smem_log_initialize();
+	return ret;
+}
+
+static struct notifier_block nb = {
+	.notifier_call = smem_module_init_notifier,
+};
+
+static int __init smem_log_init(void)
+{
+	return smem_module_init_notifier_register(&nb);
+}
+
+
+module_init(smem_log_init);
+
+MODULE_DESCRIPTION("smem log");
+MODULE_LICENSE("GPL v2");