Initial file dump from open source releaseHEADmaster

1 files changed, 1087 insertions, 0 deletions

diff --git a/arch/arm/kernel/sprd_sysdump.c b/arch/arm/kernel/sprd_sysdump.c
new file mode 100644
index 00000000..6b5fe55b
--- /dev/null
+++ b/arch/arm/kernel/sprd_sysdump.c
@@ -0,0 +1,1087 @@
+/*
+ * Copyright (C) 2013 Spreadtrum Communications Inc.
+ *
+ * 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.
+ */
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/delay.h>
+#include <linux/miscdevice.h>
+#include <linux/io.h>
+#include <linux/uaccess.h>
+#include <linux/mm.h>
+#include <linux/vmalloc.h>
+#include <linux/list.h>
+#include <linux/proc_fs.h>
+#include <linux/elf.h>
+#include <linux/elfcore.h>
+#include <linux/init.h>
+#include <linux/highuid.h>
+#include <linux/sched.h>
+#include <linux/sysctl.h>
+#include <asm/memory.h>
+#include <asm/cacheflush.h>
+#include <asm/outercache.h>
+
+#include <soc/sprd/board.h>
+#include <soc/sprd/hardware.h>
+#include <soc/sprd/sci_glb_regs.h>
+
+
+#define CORE_STR 		"CORE"
+#ifndef ELF_CORE_EFLAGS
+#define ELF_CORE_EFLAGS	0
+#endif
+
+#define NR_KCORE_MEM	80
+#define SYSDUMP_MAGIC	"SPRD_SYSDUMP_119"
+
+#define SYSDUMP_NOTE_BYTES (ALIGN(sizeof(struct elf_note), 4) +   \
+			    ALIGN(sizeof(CORE_STR), 4) + \
+			    ALIGN(sizeof(struct elf_prstatus), 4))
+
+typedef char note_buf_t[SYSDUMP_NOTE_BYTES];
+
+note_buf_t __percpu *crash_notes;
+
+/* An ELF note in memory */
+struct memelfnote
+{
+	const char *name;
+	int type;
+	unsigned int datasz;
+	void *data;
+};
+
+struct sysdump_info {
+	char magic[16];
+	char time[32];
+	char dump_path[128];
+	int elfhdr_size;
+	int mem_num;
+	unsigned long dump_mem_paddr;
+	int crash_key;
+};
+
+struct sysdump_extra {
+	int  enter_id;
+	int  enter_cpu;
+	char reason[256];
+	struct pt_regs cpu_context[CONFIG_NR_CPUS];
+};
+
+struct sysdump_config {
+	int enable;
+	int crashkey_only;
+	int dump_modem;
+	int reboot;
+	char dump_path[128];
+};
+
+static struct sysdump_info *sprd_sysdump_info = NULL;
+
+/* must be global to let gdb know */
+struct sysdump_extra sprd_sysdump_extra = {
+	.enter_id = -1,
+	.enter_cpu = -1,
+	.reason = {0},
+};
+
+static struct sysdump_config sysdump_conf = {
+	.enable = 1,
+	.crashkey_only = 0,
+	.dump_modem = 1,
+	.reboot = 1,
+	.dump_path = "",
+};
+
+#ifdef CONFIG_SPRD_SYSDUMP
+struct sysdump_mem sprd_dump_mem[] = {
+#if defined(CONFIG_ARCH_SCX15)
+#if defined(CONFIG_SPRD_MODEM_TD)
+	{
+		.paddr		= CONFIG_PHYS_OFFSET,
+		.vaddr		= PAGE_OFFSET,
+		.soff		= 0xffffffff,
+		.size		= CPT_START_ADDR - CONFIG_PHYS_OFFSET,
+		.type	 	= SYSDUMP_RAM,
+	},
+	{
+		.paddr		= CPT_START_ADDR,
+		.vaddr		= PAGE_OFFSET +
+					(CPT_START_ADDR - CONFIG_PHYS_OFFSET),
+		.soff		= 0xffffffff,
+		.size		= CPT_TOTAL_SIZE,
+#ifdef CONFIG_SIPC_TD
+		.type		= SYSDUMP_MODEM,
+#else
+		.type		= SYSDUMP_RAM,
+#endif
+	},
+	{
+		.paddr		= CPT_START_ADDR + CPT_TOTAL_SIZE,
+		.vaddr		= PAGE_OFFSET + CPT_START_ADDR + CPT_TOTAL_SIZE - CONFIG_PHYS_OFFSET,
+		.soff		= 0xffffffff,
+		.size		= WCN_START_ADDR - CPT_START_ADDR - CPT_TOTAL_SIZE,
+		.type	 	= SYSDUMP_RAM,
+	},
+#else
+	{
+		.paddr		= CONFIG_PHYS_OFFSET,
+		.vaddr		= PAGE_OFFSET,
+		.soff		= 0xffffffff,
+		.size		= CPW_START_ADDR - CONFIG_PHYS_OFFSET,
+		.type	 	= SYSDUMP_RAM,
+	},
+	{
+		.paddr		= CPW_START_ADDR,
+		.vaddr		= PAGE_OFFSET +
+					(CPW_START_ADDR - CONFIG_PHYS_OFFSET),
+		.soff		= 0xffffffff,
+		.size		= CPW_TOTAL_SIZE,
+#ifdef CONFIG_SIPC_WCDMA
+		.type		= SYSDUMP_MODEM,
+#else
+		.type		= SYSDUMP_RAM,
+#endif
+	},
+	{
+		.paddr		= CPW_START_ADDR + CPW_TOTAL_SIZE,
+		.vaddr		= PAGE_OFFSET + CPW_START_ADDR + CPW_TOTAL_SIZE - CONFIG_PHYS_OFFSET,
+		.soff		= 0xffffffff,
+		.size		= WCN_START_ADDR - CPW_START_ADDR - CPW_TOTAL_SIZE,
+		.type	 	= SYSDUMP_RAM,
+	},
+#endif
+#elif defined(CONFIG_ARCH_SCX30G)
+#if defined(CONFIG_SPRD_MODEM_TD)
+	{
+		.paddr		= CONFIG_PHYS_OFFSET,
+		.vaddr		= PAGE_OFFSET,
+		.soff		= 0xffffffff,
+		.size		= CPT_START_ADDR - CONFIG_PHYS_OFFSET,
+		.type	 	= SYSDUMP_RAM,
+	},
+
+
+	{
+		.paddr		= CPT_START_ADDR,
+		.vaddr		= PAGE_OFFSET +
+					(CPT_START_ADDR - CONFIG_PHYS_OFFSET),
+		.soff		= 0xffffffff,
+		.size		= CPT_TOTAL_SIZE,
+#ifdef CONFIG_SIPC_TD
+		.type		= SYSDUMP_MODEM,
+#else
+		.type		= SYSDUMP_RAM,
+#endif
+	},
+#else
+	{
+		.paddr		= CONFIG_PHYS_OFFSET,
+		.vaddr		= PAGE_OFFSET,
+		.soff		= 0xffffffff,
+		.size		= CPW_START_ADDR - CONFIG_PHYS_OFFSET,
+		.type		= SYSDUMP_RAM,
+	},
+
+	{
+		.paddr		= CPW_START_ADDR,
+		.vaddr		= PAGE_OFFSET +
+					(CPW_START_ADDR - CONFIG_PHYS_OFFSET),
+		.soff		= 0xffffffff,
+		.size		= CPW_TOTAL_SIZE,
+#ifdef CONFIG_SIPC_WCDMA
+		.type		= SYSDUMP_MODEM,
+#else
+		.type		= SYSDUMP_RAM,
+#endif
+	},
+#endif
+#elif defined(CONFIG_ARCH_SCX35L)
+	{
+		.paddr          = CONFIG_PHYS_OFFSET,
+		.vaddr          = PAGE_OFFSET,
+		.soff           = 0xffffffff,
+		.size           = GGE_START_ADDR - CONFIG_PHYS_OFFSET,
+		.type           = SYSDUMP_RAM,
+	},
+	{
+		.paddr		= GGE_START_ADDR,
+		.vaddr		= PAGE_OFFSET +
+					(GGE_START_ADDR - CONFIG_PHYS_OFFSET),
+		.soff		= 0xffffffff,
+		.size		= GGE_TOTAL_SIZE,
+#ifdef CONFIG_SIPC_GGE
+		.type		= SYSDUMP_MODEM,
+#else
+		.type		= SYSDUMP_RAM,
+#endif
+	},
+	{
+		.paddr		= LTE_START_ADDR,
+		.vaddr		= PAGE_OFFSET +
+					(LTE_START_ADDR - CONFIG_PHYS_OFFSET),
+		.soff		= 0xffffffff,
+		.size		= LTE_TOTAL_SIZE,
+#ifdef CONFIG_SIPC_LTE
+		.type		= SYSDUMP_MODEM,
+#else
+		.type		= SYSDUMP_RAM,
+#endif
+	},
+
+#else
+
+	{
+		.paddr		= CONFIG_PHYS_OFFSET,
+		.vaddr		= PAGE_OFFSET,
+		.soff		= 0xffffffff,
+		.size		= CPT_START_ADDR - CONFIG_PHYS_OFFSET,
+		.type	 	= SYSDUMP_RAM,
+	},
+	{
+		.paddr		= CPT_START_ADDR,
+		.vaddr		= PAGE_OFFSET +
+					(CPT_START_ADDR - CONFIG_PHYS_OFFSET),
+		.soff		= 0xffffffff,
+		.size		= CPT_TOTAL_SIZE,
+#ifdef CONFIG_SIPC_TD
+		.type		= SYSDUMP_MODEM,
+#else
+		.type		= SYSDUMP_RAM,
+#endif
+	},
+	{
+		.paddr		= CPT_START_ADDR + CPT_TOTAL_SIZE,
+		.vaddr		= PAGE_OFFSET +
+					(CPT_START_ADDR + CPT_TOTAL_SIZE - CONFIG_PHYS_OFFSET),
+		.soff		= 0xffffffff,
+		.size		= CPW_START_ADDR - (CPT_START_ADDR + CPT_TOTAL_SIZE),
+		.type		= SYSDUMP_RAM,
+	},
+	{
+		.paddr		= CPW_START_ADDR,
+		.vaddr		= PAGE_OFFSET +
+					(CPW_START_ADDR - CONFIG_PHYS_OFFSET),
+		.soff		= 0xffffffff,
+		.size		= CPW_TOTAL_SIZE,
+#ifdef CONFIG_SIPC_WCDMA
+		.type		= SYSDUMP_MODEM,
+#else
+		.type		= SYSDUMP_RAM,
+#endif
+	},
+#endif
+#ifdef CONFIG_ARCH_SCX35L
+	{
+		.paddr		= LTE_START_ADDR + LTE_TOTAL_SIZE,
+		.vaddr		= PAGE_OFFSET +
+						(LTE_START_ADDR + LTE_TOTAL_SIZE - CONFIG_PHYS_OFFSET),
+		.soff		= 0xffffffff,
+		.size		= 0,
+		.type		= SYSDUMP_RAM,
+	},
+#else
+	{
+		.paddr		= WCN_START_ADDR,
+		.vaddr		= PAGE_OFFSET +
+					(WCN_START_ADDR - CONFIG_PHYS_OFFSET),
+		.soff		= 0xffffffff,
+		.size		= WCN_TOTAL_SIZE,
+//#ifdef CONFIG_SIPC_WCN
+		.type		= SYSDUMP_MODEM,
+//#else
+//		.type		= SYSDUMP_RAM,
+//#endif
+	},
+	{
+		.paddr		= WCN_START_ADDR + WCN_TOTAL_SIZE,
+		.vaddr		= PAGE_OFFSET +
+					(WCN_START_ADDR + WCN_TOTAL_SIZE - CONFIG_PHYS_OFFSET),
+		.soff		= 0xffffffff,
+		.size		= 0, /* fill this dynamically according to real ram size */
+		.type		= SYSDUMP_RAM,
+	},
+#endif
+/*	{
+		.paddr		= SPRD_AHB_PHYS,
+		.vaddr		= SPRD_AHB_BASE,
+		.soff		= 0x0,
+		.size		= SPRD_AHB_SIZE,
+		.type		= SYSDUMP_IOMEM,
+	},
+	{
+		.paddr		= SPRD_INTC0_PHYS,
+		.vaddr		= SPRD_INTC0_BASE,
+		.soff		= 0x0,
+		.size		= SPRD_INTC0_SIZE,
+		.type		= SYSDUMP_IOMEM,
+	},
+	{
+		.paddr		= SPRD_GPTIMER0_PHYS,
+		.vaddr		= SPRD_GPTIMER0_BASE,
+		.soff		= 0x0,
+		.size		= SPRD_GPTIMER0_SIZE,
+		.type		= SYSDUMP_IOMEM,
+	},
+	{
+		.paddr		= SPRD_ADI_PHYS,
+		.vaddr		= SPRD_ADI_BASE,
+		.soff		= 0x0,
+		.size		= SPRD_ADI_SIZE,
+		.type		= SYSDUMP_IOMEM,
+	},
+	{
+		.paddr		= SPRD_GPIO_PHYS,
+		.vaddr		= SPRD_GPIO_BASE,
+		.soff		= 0x0,
+		.size		= SPRD_GPIO_SIZE,
+		.type		= SYSDUMP_IOMEM,
+	},
+	{
+		.paddr		= SPRD_EIC_PHYS,
+		.vaddr		= SPRD_EIC_BASE,
+		.soff		= 0x0,
+		.size		= SPRD_EIC_SIZE,
+		.type		= SYSDUMP_IOMEM,
+	},
+	{
+		.paddr		= SPRD_GREG_PHYS,
+		.vaddr		= SPRD_GREG_BASE,
+		.soff		= 0x0,
+		.size		= SPRD_GREG_SIZE,
+		.type		= SYSDUMP_IOMEM,
+	},*/
+};
+int sprd_dump_mem_num = ARRAY_SIZE(sprd_dump_mem);
+#endif /* CONFIG_SPRD_SYSDUMP */
+
+static size_t get_elfhdr_size(int nphdr)
+{
+	size_t elfhdr_len;
+
+	elfhdr_len = sizeof(struct elfhdr) +
+		(nphdr + 1)*sizeof(struct elf_phdr) +
+		((sizeof(struct elf_note)) * 3 +
+		roundup(sizeof(CORE_STR), 4)) +
+		roundup(sizeof(struct elf_prstatus), 4) +
+		roundup(sizeof(struct elf_prpsinfo), 4) +
+		roundup(sizeof(struct task_struct), 4);
+	elfhdr_len = PAGE_ALIGN(elfhdr_len);
+
+	return elfhdr_len;
+}
+
+static int notesize(struct memelfnote *en)
+{
+	int sz;
+
+	sz = sizeof(struct elf_note);
+	sz += roundup((strlen(en->name) + 1), 4);
+	sz += roundup(en->datasz, 4);
+
+	return sz;
+}
+
+static char *storenote(struct memelfnote *men, char *bufp)
+{
+	struct elf_note en;
+
+#define DUMP_WRITE(addr,nr) do { memcpy(bufp,addr,nr); bufp += nr; } while(0)
+
+	en.n_namesz = strlen(men->name) + 1;
+	en.n_descsz = men->datasz;
+	en.n_type = men->type;
+
+	DUMP_WRITE(&en, sizeof(en));
+	DUMP_WRITE(men->name, en.n_namesz);
+
+	/* XXX - cast from long long to long to avoid need for libgcc.a */
+	bufp = (char*) roundup((unsigned long)bufp,4);
+	DUMP_WRITE(men->data, men->datasz);
+	bufp = (char*) roundup((unsigned long)bufp,4);
+
+#undef DUMP_WRITE
+
+	return bufp;
+}
+
+/*
+ * fill up all the fields in prstatus from the given task struct, except
+ * registers which need to be filled up separately.
+ */
+static void fill_prstatus(struct elf_prstatus *prstatus,
+		struct task_struct *p, long signr)
+{
+	prstatus->pr_info.si_signo = prstatus->pr_cursig = signr;
+	prstatus->pr_sigpend = p->pending.signal.sig[0];
+	prstatus->pr_sighold = p->blocked.sig[0];
+	rcu_read_lock();
+	prstatus->pr_ppid = task_pid_vnr(rcu_dereference(p->real_parent));
+	rcu_read_unlock();
+	prstatus->pr_pid = task_pid_vnr(p);
+	prstatus->pr_pgrp = task_pgrp_vnr(p);
+	prstatus->pr_sid = task_session_vnr(p);
+	if ( 0 /* thread_group_leader(p) */) {
+		struct task_cputime cputime;
+
+		/*
+		 * This is the record for the group leader.  It shows the
+		 * group-wide total, not its individual thread total.
+		 */
+		/* thread_group_cputime(p, &cputime); */
+		cputime_to_timeval(cputime.utime, &prstatus->pr_utime);
+		cputime_to_timeval(cputime.stime, &prstatus->pr_stime);
+	} else {
+		cputime_to_timeval(p->utime, &prstatus->pr_utime);
+		cputime_to_timeval(p->stime, &prstatus->pr_stime);
+	}
+	cputime_to_timeval(p->signal->cutime, &prstatus->pr_cutime);
+	cputime_to_timeval(p->signal->cstime, &prstatus->pr_cstime);
+}
+
+static int fill_psinfo(struct elf_prpsinfo *psinfo, struct task_struct *p,
+		       struct mm_struct *mm)
+{
+	const struct cred *cred;
+	unsigned int i, len;
+
+	/* first copy the parameters from user space */
+	memset(psinfo, 0, sizeof(struct elf_prpsinfo));
+
+	if (mm) {
+		len = mm->arg_end - mm->arg_start;
+		if (len >= ELF_PRARGSZ)
+			len = ELF_PRARGSZ-1;
+		if (copy_from_user(&psinfo->pr_psargs,
+			           (const char __user *)mm->arg_start, len))
+			return -EFAULT;
+		for(i = 0; i < len; i++)
+			if (psinfo->pr_psargs[i] == 0)
+				psinfo->pr_psargs[i] = ' ';
+		psinfo->pr_psargs[len] = 0;
+	}
+
+	rcu_read_lock();
+	psinfo->pr_ppid = task_pid_vnr(rcu_dereference(p->real_parent));
+	rcu_read_unlock();
+	psinfo->pr_pid = task_pid_vnr(p);
+	psinfo->pr_pgrp = task_pgrp_vnr(p);
+	psinfo->pr_sid = task_session_vnr(p);
+
+	i = p->state ? ffz(~p->state) + 1 : 0;
+	psinfo->pr_state = i;
+	psinfo->pr_sname = (i > 5) ? '.' : "RSDTZW"[i];
+	psinfo->pr_zomb = psinfo->pr_sname == 'Z';
+	psinfo->pr_nice = task_nice(p);
+	psinfo->pr_flag = p->flags;
+
+	rcu_read_lock();
+	cred = __task_cred(p);
+	SET_UID(psinfo->pr_uid, cred->uid);
+	SET_GID(psinfo->pr_gid, cred->gid);
+	rcu_read_unlock();
+	strncpy(psinfo->pr_fname, p->comm, sizeof(psinfo->pr_fname));
+
+	return 0;
+}
+
+/**
+ * crash_setup_regs() - save registers for the panic kernel
+ * @newregs: registers are saved here
+ * @oldregs: registers to be saved (may be %NULL)
+ *
+ * Function copies machine registers from @oldregs to @newregs. If @oldregs is
+ * %NULL then current registers are stored there.
+ */
+static inline void crash_setup_regs(struct pt_regs *newregs,
+				    struct pt_regs *oldregs)
+{
+	if (oldregs) {
+		memcpy(newregs, oldregs, sizeof(*newregs));
+	} else {
+		__asm__ __volatile__ (
+			"stmia	%[regs_base], {r0-r12}\n\t"
+			"mov	%[_ARM_sp], sp\n\t"
+			"str	lr, %[_ARM_lr]\n\t"
+			"adr	%[_ARM_pc], 1f\n\t"
+			"mrs	%[_ARM_cpsr], cpsr\n\t"
+		"1:"
+			: [_ARM_pc] "=r" (newregs->ARM_pc),
+			  [_ARM_cpsr] "=r" (newregs->ARM_cpsr),
+			  [_ARM_sp] "=r" (newregs->ARM_sp),
+			  [_ARM_lr] "=o" (newregs->ARM_lr)
+			: [regs_base] "r" (&newregs->ARM_r0)
+			: "memory"
+		);
+	}
+}
+
+void crash_note_save_cpu(struct pt_regs *regs, int cpu)
+{
+	struct elf_prstatus prstatus;
+	struct memelfnote notes;
+
+	notes.name = CORE_STR;
+	notes.type = NT_PRSTATUS;
+	notes.datasz = sizeof(struct elf_prstatus);
+	notes.data = &prstatus;
+
+	memset(&prstatus, 0, sizeof(struct elf_prstatus));
+	fill_prstatus(&prstatus, current, 0);
+	memcpy(&prstatus.pr_reg, regs, sizeof(struct pt_regs));
+	storenote(&notes, per_cpu_ptr(crash_notes, cpu));
+}
+
+static void sysdump_fill_core_hdr(struct pt_regs *regs,
+						struct sysdump_mem *sysmem, int mem_num,
+						char *bufp, int nphdr, int dataoff)
+{
+	struct elf_prstatus prstatus;	/* NT_PRSTATUS */
+	struct elf_prpsinfo prpsinfo;	/* NT_PRPSINFO */
+	struct elf_phdr *nhdr, *phdr;
+	struct elfhdr *elf;
+	struct memelfnote notes;
+	off_t offset = 0;
+	int i;
+
+	/* setup ELF header */
+	elf = (struct elfhdr *) bufp;
+	bufp += sizeof(struct elfhdr);
+	offset += sizeof(struct elfhdr);
+	memcpy(elf->e_ident, ELFMAG, SELFMAG);
+	elf->e_ident[EI_CLASS]	= ELF_CLASS;
+	elf->e_ident[EI_DATA]	= ELF_DATA;
+	elf->e_ident[EI_VERSION]= EV_CURRENT;
+	elf->e_ident[EI_OSABI] = ELF_OSABI;
+	memset(elf->e_ident+EI_PAD, 0, EI_NIDENT-EI_PAD);
+	elf->e_type	= ET_CORE;
+	elf->e_machine	= ELF_ARCH;
+	elf->e_version	= EV_CURRENT;
+	elf->e_entry	= 0;
+	elf->e_phoff	= sizeof(struct elfhdr);
+	elf->e_shoff	= 0;
+	elf->e_flags	= ELF_CORE_EFLAGS;
+	elf->e_ehsize	= sizeof(struct elfhdr);
+	elf->e_phentsize= sizeof(struct elf_phdr);
+	elf->e_phnum	= nphdr;
+	elf->e_shentsize= 0;
+	elf->e_shnum	= 0;
+	elf->e_shstrndx	= 0;
+
+	/* setup ELF PT_NOTE program header */
+	nhdr = (struct elf_phdr *) bufp;
+	bufp += sizeof(struct elf_phdr);
+	offset += sizeof(struct elf_phdr);
+	nhdr->p_type	= PT_NOTE;
+	nhdr->p_offset	= 0;
+	nhdr->p_vaddr	= 0;
+	nhdr->p_paddr	= 0;
+	nhdr->p_filesz	= 0;
+	nhdr->p_memsz	= SYSDUMP_NOTE_BYTES*NR_CPUS;
+	nhdr->p_flags	= 0;
+	nhdr->p_align	= 0;
+
+	/* setup ELF PT_LOAD program header for every area */
+	for (i = 0; i < mem_num; i++) {
+		phdr = (struct elf_phdr *) bufp;
+		bufp += sizeof(struct elf_phdr);
+		offset += sizeof(struct elf_phdr);
+
+		phdr->p_type	= PT_LOAD;
+		phdr->p_flags	= PF_R|PF_W|PF_X;
+		phdr->p_offset	= dataoff;
+		phdr->p_vaddr	= sysmem[i].vaddr;
+		phdr->p_paddr	= sysmem[i].paddr;
+		phdr->p_filesz	= phdr->p_memsz	= sysmem[i].size;
+		phdr->p_align	= 0;//PAGE_SIZE;
+		dataoff += sysmem[i].size;
+	}
+
+	/*
+	 * Set up the notes in similar form to SVR4 core dumps made
+	 * with info from their /proc.
+	 */
+	nhdr->p_offset	= offset;
+	nhdr->p_filesz = 0;
+
+	return;
+} /* end elf_kcore_store_hdr() */
+
+static void sysdump_prepare_info(int enter_id, const char *reason,
+	struct pt_regs *regs)
+{
+	unsigned long long t;
+	unsigned long nanosec_rem;
+	int iocnt, i;
+	char *iomem;
+
+	strncpy(sprd_sysdump_extra.reason,
+		reason, sizeof(sprd_sysdump_extra.reason));
+	sprd_sysdump_extra.enter_id = enter_id;
+
+	/* sprd_sysdump_info = (struct sysdump_info *)phys_to_virt(SPRD_SYSDUMP_MAGIC);  */
+	if(sprd_sysdump_info == NULL){
+		printk(KERN_ERR"[ sysdump_prepare_info ] sprd_sysdump_info ioremap error!! \n");
+		return;
+	}
+	printk("vaddr is %p,paddr is %p\n",sprd_sysdump_info, (void *)SPRD_SYSDUMP_MAGIC);
+	memcpy(sprd_sysdump_info->magic, SYSDUMP_MAGIC,
+			sizeof(sprd_sysdump_info->magic));
+
+	if (reason != NULL && !strcmp(reason, "Crash Key")) {
+		sprd_sysdump_info->crash_key = 1;
+	} else {
+		sprd_sysdump_info->crash_key = 0;
+	}
+
+	printk("reason: %s, sprd_sysdump_info->crash_key: %d\n", reason, sprd_sysdump_info->crash_key);
+
+	t = cpu_clock(smp_processor_id());
+	nanosec_rem = do_div(t, 1000000000);
+	sprintf(sprd_sysdump_info->time, "%lu.%06lu", (unsigned long)t,
+			nanosec_rem / 1000);
+
+	memcpy(sprd_sysdump_info->dump_path, sysdump_conf.dump_path,
+		sizeof(sprd_sysdump_info->dump_path));
+
+	sprd_sysdump_info->dump_mem_paddr = virt_to_phys(sprd_dump_mem);
+	sprd_sysdump_info->mem_num = sprd_dump_mem_num;
+	sprd_sysdump_info->elfhdr_size = get_elfhdr_size(sprd_sysdump_info->mem_num);
+
+	/* this must before sysdump_fill_core_hdr, it needs size */
+	for (i = 0; i < sprd_dump_mem_num; i++) {
+		if (SYSDUMP_RAM == sprd_dump_mem[i].type && 0 == sprd_dump_mem[i].size)
+			sprd_dump_mem[i].size = CONFIG_PHYS_OFFSET +
+						(num_physpages << PAGE_SHIFT) -
+						sprd_dump_mem[i].paddr;
+
+		if (!sysdump_conf.dump_modem && SYSDUMP_MODEM == sprd_dump_mem[i].type)
+			sprd_dump_mem[i].size = 0;
+	}
+
+	sysdump_fill_core_hdr(regs,
+		sprd_dump_mem,
+		sprd_dump_mem_num,
+		(char *)sprd_sysdump_info + sizeof(*sprd_sysdump_info),
+		sprd_sysdump_info->mem_num + 1,
+		sprd_sysdump_info->elfhdr_size);
+
+	iocnt = 0;
+	for (i = 0; i < sprd_dump_mem_num; i++) {
+		/* save iomem(regiters) to ram, cause they will change while rebooting */
+		if (0xffffffff != sprd_dump_mem[i].soff) {
+			sprd_dump_mem[i].soff = iocnt;
+			iomem = (char *)sprd_sysdump_info + sizeof(*sprd_sysdump_info) +
+					sprd_sysdump_info->elfhdr_size + iocnt;
+			memcpy(iomem, 
+				(void const *)(sprd_dump_mem[i].vaddr), 
+				sprd_dump_mem[i].size);
+			iocnt += sprd_dump_mem[i].size;
+		}
+	}
+
+	return;
+}
+
+
+struct sprd_debug_mmu_reg_t {
+	int SCTLR;
+	int TTBR0;
+	int TTBR1;
+	int TTBCR;
+	int DACR;
+	int DFSR;
+	int DFAR;
+	int IFSR;
+	int IFAR;
+	int DAFSR;
+	int IAFSR;
+	int PMRRR;
+	int NMRRR;
+	int FCSEPID;
+	int CONTEXT;
+	int URWTPID;
+	int UROTPID;
+	int POTPIDR;
+};
+
+/* ARM CORE regs mapping structure */
+struct sprd_debug_core_t {
+	/* COMMON */
+	unsigned int r0;
+	unsigned int r1;
+	unsigned int r2;
+	unsigned int r3;
+	unsigned int r4;
+	unsigned int r5;
+	unsigned int r6;
+	unsigned int r7;
+	unsigned int r8;
+	unsigned int r9;
+	unsigned int r10;
+	unsigned int r11;
+	unsigned int r12;
+
+	/* SVC */
+	unsigned int r13_svc;
+	unsigned int r14_svc;
+	unsigned int spsr_svc;
+
+	/* PC & CPSR */
+	unsigned int pc;
+	unsigned int cpsr;
+
+	/* USR/SYS */
+	unsigned int r13_usr;
+	unsigned int r14_usr;
+
+	/* FIQ */
+	unsigned int r8_fiq;
+	unsigned int r9_fiq;
+	unsigned int r10_fiq;
+	unsigned int r11_fiq;
+	unsigned int r12_fiq;
+	unsigned int r13_fiq;
+	unsigned int r14_fiq;
+	unsigned int spsr_fiq;
+
+	/* IRQ */
+	unsigned int r13_irq;
+	unsigned int r14_irq;
+	unsigned int spsr_irq;
+
+	/* MON */
+	unsigned int r13_mon;
+	unsigned int r14_mon;
+	unsigned int spsr_mon;
+
+	/* ABT */
+	unsigned int r13_abt;
+	unsigned int r14_abt;
+	unsigned int spsr_abt;
+
+	/* UNDEF */
+	unsigned int r13_und;
+	unsigned int r14_und;
+	unsigned int spsr_und;
+
+};
+
+DEFINE_PER_CPU(struct sprd_debug_core_t, sprd_debug_core_reg);
+DEFINE_PER_CPU(struct sprd_debug_mmu_reg_t, sprd_debug_mmu_reg);
+
+
+/* core reg dump function*/
+static inline void sprd_debug_save_core_reg(struct sprd_debug_core_t *core_reg)
+{
+	/* we will be in SVC mode when we enter this function. Collect
+	 *	   SVC registers along with cmn registers. */
+	asm("str r0, [%0,#0]\n\t"	/* R0 is pushed first to core_reg */
+			"mov r0, %0\n\t"		/* R0 will be alias for core_reg */
+			"str r1, [r0,#4]\n\t"	/* R1 */
+			"str r2, [r0,#8]\n\t"	/* R2 */
+			"str r3, [r0,#12]\n\t"	/* R3 */
+			"str r4, [r0,#16]\n\t"	/* R4 */
+			"str r5, [r0,#20]\n\t"	/* R5 */
+			"str r6, [r0,#24]\n\t"	/* R6 */
+			"str r7, [r0,#28]\n\t"	/* R7 */
+			"str r8, [r0,#32]\n\t"	/* R8 */
+			"str r9, [r0,#36]\n\t"	/* R9 */
+			"str r10, [r0,#40]\n\t"	/* R10 */
+			"str r11, [r0,#44]\n\t"	/* R11 */
+			"str r12, [r0,#48]\n\t"	/* R12 */
+			/* SVC */
+			"str r13, [r0,#52]\n\t"	/* R13_SVC */
+			"str r14, [r0,#56]\n\t"	/* R14_SVC */
+			"mrs r1, spsr\n\t"		/* SPSR_SVC */
+			"str r1, [r0,#60]\n\t"
+			/* PC and CPSR */
+			"sub r1, r15, #0x4\n\t"	/* PC */
+			"str r1, [r0,#64]\n\t"
+			"mrs r1, cpsr\n\t"		/* CPSR */
+			"str r1, [r0,#68]\n\t"
+			/* SYS/USR */
+			"mrs r1, cpsr\n\t"		/* switch to SYS mode */
+			"and r1, r1, #0xFFFFFFE0\n\t"
+			"orr r1, r1, #0x1f\n\t"
+			"msr cpsr,r1\n\t"
+			"str r13, [r0,#72]\n\t"	/* R13_USR */
+			"str r14, [r0,#76]\n\t"	/* R14_USR */
+			/* FIQ */
+			"mrs r1, cpsr\n\t"		/* switch to FIQ mode */
+			"and r1,r1,#0xFFFFFFE0\n\t"
+			"orr r1,r1,#0x11\n\t"
+			"msr cpsr,r1\n\t"
+			"str r8, [r0,#80]\n\t"	/* R8_FIQ */
+			"str r9, [r0,#84]\n\t"	/* R9_FIQ */
+			"str r10, [r0,#88]\n\t"	/* R10_FIQ */
+			"str r11, [r0,#92]\n\t"	/* R11_FIQ */
+			"str r12, [r0,#96]\n\t"	/* R12_FIQ */
+			"str r13, [r0,#100]\n\t"	/* R13_FIQ */
+			"str r14, [r0,#104]\n\t"	/* R14_FIQ */
+			"mrs r1, spsr\n\t"		/* SPSR_FIQ */
+			"str r1, [r0,#108]\n\t"
+			/* IRQ */
+			"mrs r1, cpsr\n\t"		/* switch to IRQ mode */
+			"and r1, r1, #0xFFFFFFE0\n\t"
+			"orr r1, r1, #0x12\n\t"
+			"msr cpsr,r1\n\t"
+			"str r13, [r0,#112]\n\t"	/* R13_IRQ */
+			"str r14, [r0,#116]\n\t"	/* R14_IRQ */
+			"mrs r1, spsr\n\t"		/* SPSR_IRQ */
+			"str r1, [r0,#120]\n\t"
+			/* MON */
+			"mrs r1, cpsr\n\t"		/* switch to monitor mode */
+			"and r1, r1, #0xFFFFFFE0\n\t"
+			"orr r1, r1, #0x16\n\t"
+			"msr cpsr,r1\n\t"
+			"str r13, [r0,#124]\n\t"	/* R13_MON */
+			"str r14, [r0,#128]\n\t"	/* R14_MON */
+			"mrs r1, spsr\n\t"		/* SPSR_MON */
+			"str r1, [r0,#132]\n\t"
+			/* ABT */
+			"mrs r1, cpsr\n\t"		/* switch to Abort mode */
+			"and r1, r1, #0xFFFFFFE0\n\t"
+			"orr r1, r1, #0x17\n\t"
+			"msr cpsr,r1\n\t"
+			"str r13, [r0,#136]\n\t"	/* R13_ABT */
+			"str r14, [r0,#140]\n\t"	/* R14_ABT */
+			"mrs r1, spsr\n\t"		/* SPSR_ABT */
+			"str r1, [r0,#144]\n\t"
+			/* UND */
+			"mrs r1, cpsr\n\t"		/* switch to undef mode */
+			"and r1, r1, #0xFFFFFFE0\n\t"
+			"orr r1, r1, #0x1B\n\t"
+			"msr cpsr,r1\n\t"
+			"str r13, [r0,#148]\n\t"	/* R13_UND */
+			"str r14, [r0,#152]\n\t"	/* R14_UND */
+			"mrs r1, spsr\n\t"		/* SPSR_UND */
+			"str r1, [r0,#156]\n\t"
+			/* restore to SVC mode */
+			"mrs r1, cpsr\n\t"		/* switch to SVC mode */
+			"and r1, r1, #0xFFFFFFE0\n\t"
+			"orr r1, r1, #0x13\n\t"
+			"msr cpsr,r1\n\t" :		/* output */
+			: "r"(core_reg)		/* input */
+			: "%r0", "%r1"		/* clobbered registers */
+				);
+
+	return;
+}
+
+static inline void sprd_debug_save_mmu_reg(struct sprd_debug_mmu_reg_t *mmu_reg)
+{
+	asm("mrc    p15, 0, r1, c1, c0, 0\n\t"	/* SCTLR */
+			"str r1, [%0]\n\t"
+			"mrc    p15, 0, r1, c2, c0, 0\n\t"	/* TTBR0 */
+			"str r1, [%0,#4]\n\t"
+			"mrc    p15, 0, r1, c2, c0,1\n\t"	/* TTBR1 */
+			"str r1, [%0,#8]\n\t"
+			"mrc    p15, 0, r1, c2, c0,2\n\t"	/* TTBCR */
+			"str r1, [%0,#12]\n\t"
+			"mrc    p15, 0, r1, c3, c0,0\n\t"	/* DACR */
+			"str r1, [%0,#16]\n\t"
+			"mrc    p15, 0, r1, c5, c0,0\n\t"	/* DFSR */
+			"str r1, [%0,#20]\n\t"
+			"mrc    p15, 0, r1, c6, c0,0\n\t"	/* DFAR */
+			"str r1, [%0,#24]\n\t"
+			"mrc    p15, 0, r1, c5, c0,1\n\t"	/* IFSR */
+			"str r1, [%0,#28]\n\t"
+			"mrc    p15, 0, r1, c6, c0,2\n\t"	/* IFAR */
+			"str r1, [%0,#32]\n\t"
+			/* Don't populate DAFSR and RAFSR */
+			"mrc    p15, 0, r1, c10, c2,0\n\t"	/* PMRRR */
+			"str r1, [%0,#44]\n\t"
+			"mrc    p15, 0, r1, c10, c2,1\n\t"	/* NMRRR */
+			"str r1, [%0,#48]\n\t"
+			"mrc    p15, 0, r1, c13, c0,0\n\t"	/* FCSEPID */
+			"str r1, [%0,#52]\n\t"
+			"mrc    p15, 0, r1, c13, c0,1\n\t"	/* CONTEXT */
+			"str r1, [%0,#56]\n\t"
+			"mrc    p15, 0, r1, c13, c0,2\n\t"	/* URWTPID */
+			"str r1, [%0,#60]\n\t"
+			"mrc    p15, 0, r1, c13, c0,3\n\t"	/* UROTPID */
+			"str r1, [%0,#64]\n\t"
+			"mrc    p15, 0, r1, c13, c0,4\n\t"	/* POTPIDR */
+			"str r1, [%0,#68]\n\t" :		/* output */
+			: "r"(mmu_reg)			/* input */
+			: "%r1", "memory"			/* clobbered register */
+				);
+}
+
+static inline void sprd_debug_save_context(void)
+{
+	unsigned long flags;
+	local_irq_save(flags);
+	sprd_debug_save_mmu_reg(&per_cpu(sprd_debug_mmu_reg, smp_processor_id()));
+	sprd_debug_save_core_reg(&per_cpu
+			(sprd_debug_core_reg, smp_processor_id()));
+
+	pr_emerg("(%s) context saved(CPU:%d)\n", __func__, smp_processor_id());
+	local_irq_restore(flags);
+
+	flush_cache_all();
+}
+
+
+extern void emergency_restart(void);
+void sysdump_enter(int enter_id, const char *reason, struct pt_regs *regs)
+{
+	struct pt_regs * pregs;
+	if (!sysdump_conf.enable)
+		return;
+
+	if ((sysdump_conf.crashkey_only) && !(reason != NULL && !strcmp(reason, "Crash Key")))
+		return;
+
+	/* this should before smp_send_stop() to make sysdump_ipi enable */
+	sprd_sysdump_extra.enter_cpu = smp_processor_id();
+
+	pregs = &sprd_sysdump_extra.cpu_context[sprd_sysdump_extra.enter_cpu];
+	if (regs)
+		memcpy(pregs, regs, sizeof(*regs));
+	else
+		crash_setup_regs((struct pt_regs *)pregs, NULL);
+
+	crash_note_save_cpu(pregs, sprd_sysdump_extra.enter_cpu);
+	sprd_debug_save_context();
+
+	smp_send_stop();
+	mdelay(1000);
+
+	printk("\n");
+	printk("*****************************************************\n");
+	printk("*                                                   *\n");
+	printk("*  Sysdump enter, preparing debug info to dump ...  *\n");
+	printk("*                                                   *\n");
+	printk("*****************************************************\n");
+	printk("\n");
+
+	flush_cache_all();
+	outer_flush_all();
+	mdelay(1000);
+
+	sysdump_prepare_info(enter_id, reason, regs);
+
+	flush_cache_all();
+	outer_flush_all();
+	mdelay(1000);
+
+	printk("\n");
+	printk("*****************************************************\n");
+	printk("*                                                   *\n");
+	printk("*  Try to reboot system ...                         *\n");
+	printk("*                                                   *\n");
+	printk("*****************************************************\n");
+	printk("\n");
+
+	emergency_restart();
+
+
+	return;
+}
+
+void sysdump_ipi(struct pt_regs *regs)
+{
+	int cpu = smp_processor_id();
+
+	if (sprd_sysdump_extra.enter_cpu != -1)
+	{
+		memcpy((void *)&(sprd_sysdump_extra.cpu_context[cpu]),
+				(void *)regs, sizeof(struct pt_regs));
+		crash_note_save_cpu(regs, cpu);
+		sprd_debug_save_context();
+	}
+	return;
+}
+
+
+static ctl_table sysdump_sysctl_table[] = {
+	{
+		.procname       = "sysdump_enable",
+		.data           = &sysdump_conf.enable,
+		.maxlen         = sizeof(int),
+		.mode           = 0644,
+		.proc_handler   = proc_dointvec,
+	},
+	{
+		.procname       = "sysdump_crashkey_only",
+		.data           = &sysdump_conf.crashkey_only,
+		.maxlen         = sizeof(int),
+		.mode           = 0644,
+		.proc_handler   = proc_dointvec,
+	},
+	{
+		.procname       = "sysdump_dump_modem",
+		.data           = &sysdump_conf.dump_modem,
+		.maxlen         = sizeof(int),
+		.mode           = 0644,
+		.proc_handler   = proc_dointvec,
+	},
+	{
+		.procname       = "sysdump_reboot",
+		.data           = &sysdump_conf.reboot,
+		.maxlen         = sizeof(int),
+		.mode           = 0644,
+		.proc_handler   = proc_dointvec,
+	},
+	{
+		.procname       = "sysdump_dump_path",
+		.data           = sysdump_conf.dump_path,
+		.maxlen         = sizeof(sysdump_conf.dump_path),
+		.mode           = 0644,
+		.proc_handler   = proc_dostring,
+	},
+	{}
+};
+
+static ctl_table sysdump_sysctl_root[] = {
+	{
+		.procname	= "kernel",
+		.mode		= 0555,
+		.child		= sysdump_sysctl_table,
+	},
+	{}
+};
+
+
+static struct ctl_table_header *sysdump_sysctl_hdr = NULL;
+
+int sysdump_sysctl_init(void)
+{
+	char *phy_sprd_sysdump_magic;
+
+	sysdump_sysctl_hdr = register_sysctl_table(sysdump_sysctl_root);
+	if (!sysdump_sysctl_hdr)
+		return -ENOMEM;
+	phy_sprd_sysdump_magic =((SPRD_SYSDUMP_MAGIC & (~(SZ_256M - 1))) + SZ_256M - SZ_1M);
+	/* FIXME: replace ioremap with some other methods... */
+	sprd_sysdump_info = (struct sysdump_info *)ioremap(phy_sprd_sysdump_magic, SZ_1M);
+
+	crash_notes = alloc_percpu(note_buf_t);
+
+	return 0;
+}
+
+void sysdump_sysctl_exit(void)
+{
+	if (sysdump_sysctl_hdr)
+		unregister_sysctl_table(sysdump_sysctl_hdr);
+}
+
+module_init(sysdump_sysctl_init);
+module_exit(sysdump_sysctl_exit);
+
+MODULE_AUTHOR("Jianjun.He <jianjun.he@spreadtrum.com>");
+MODULE_DESCRIPTION("kernel core dump for Spreadtrum");
+MODULE_LICENSE("GPL");