[Feature][task-view-998]merge P56U10 version, ZXW code
Only Configure: No
Affected branch: master
Affected module: unknow
Is it affected on both ZXIC and MTK: only ZXIC
Self-test: No
Doc Update: No
Change-Id: I466f2ab935c5ede0be1803c75518b2cc4f939c15
diff --git a/ap/os/linux/linux-3.4.x/arch/arm/mach-zx297520v3/reset.c b/ap/os/linux/linux-3.4.x/arch/arm/mach-zx297520v3/reset.c
index 28b8625..aa78d41 100755
--- a/ap/os/linux/linux-3.4.x/arch/arm/mach-zx297520v3/reset.c
+++ b/ap/os/linux/linux-3.4.x/arch/arm/mach-zx297520v3/reset.c
@@ -31,6 +31,7 @@
#include <linux/mfd/zx234290.h>
#include <linux/delay.h>
#include <linux/reboot.h>
+#include <linux/sched.h>
#define ZX_RESET_DEV "/dev/zx_reset"
@@ -86,6 +87,7 @@
extern void zx_denali_nand_lock(void);
extern void zx_denali_nand_unlock(void);
+extern void zxic_reset_reason(int reason, const char *cpu, const char *app);
void zx29_restart(char mode, const char *cmd)
@@ -98,6 +100,8 @@
u8 restart_flag = 0;
unsigned char status = USER_RST_UNDEFINE;
+ zxic_reset_reason(2, "ap", current->comm);
+
if (cmd == NULL) {
printk(KERN_INFO"restart:enter reboot :reset to normal\n");
@@ -171,7 +175,7 @@
soft_spin_unlock_psm(I2C2_SFLOCK);
local_irq_enable();
} else {
- ret = Zx234290_SetUserReg_PSM(USER_RST_TO_NORMAL);
+ ret = Zx234290_SetUserReg_PSM(USER_RST_TO_EXCEPT);
if (ret) {
panic("restart:set restar flag error!\n");
}
diff --git a/ap/os/linux/linux-3.4.x/arch/arm/mm/fault.c b/ap/os/linux/linux-3.4.x/arch/arm/mm/fault.c
index 9cef922..cbd0917 100755
--- a/ap/os/linux/linux-3.4.x/arch/arm/mm/fault.c
+++ b/ap/os/linux/linux-3.4.x/arch/arm/mm/fault.c
@@ -1,4 +1,13 @@
-
+/*
+ * linux/arch/arm/mm/fault.c
+ *
+ * Copyright (C) 1995 Linus Torvalds
+ * Modifications for ARM processor (c) 1995-2004 Russell King
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
#include <linux/module.h>
#include <linux/signal.h>
#include <linux/mm.h>
@@ -10,295 +19,928 @@
#include <linux/sched.h>
#include <linux/highmem.h>
#include <linux/perf_event.h>
+
#include <asm/exception.h>
#include <asm/pgtable.h>
#include <asm/system_misc.h>
#include <asm/system_info.h>
#include <asm/tlbflush.h>
+
#include <asm/mach/map.h>
#include <linux/slab.h>
+
#include "fault.h"
+
#ifdef CONFIG_MMU
+
#ifdef CONFIG_KPROBES
-static inline int notify_page_fault(struct pt_regs*regs,unsigned int fsr){int
-ret=(0xe17+2085-0x163c);if(!user_mode(regs)){preempt_disable();if(kprobe_running
-()&&kprobe_fault_handler(regs,fsr))ret=(0x8c+9569-0x25ec);preempt_enable();}
-return ret;}
-#else
-static inline int notify_page_fault(struct pt_regs*regs,unsigned int fsr){return
-(0x1483+202-0x154d);}
-#endif
-void show_pte(struct mm_struct*mm,unsigned long addr){pgd_t*pgd;if(!mm)mm=&
-init_mm;printk(KERN_ALERT"\x70\x67\x64\x20\x3d\x20\x25\x70" "\n",mm->pgd);pgd=
-pgd_offset(mm,addr);printk(KERN_ALERT
-"\x5b\x25\x30\x38\x6c\x78\x5d\x20\x2a\x70\x67\x64\x3d\x25\x30\x38\x6c\x6c\x78",
-addr,(long long)pgd_val(*pgd));do{pud_t*pud;pmd_t*pmd;pte_t*pte;if(pgd_none(*pgd
-))break;if(pgd_bad(*pgd)){printk("\x28\x62\x61\x64\x29");break;}pud=pud_offset(
-pgd,addr);if(PTRS_PER_PUD!=(0x1643+673-0x18e3))printk(
-"\x2c\x20\x2a\x70\x75\x64\x3d\x25\x30\x38\x6c\x6c\x78",(long long)pud_val(*pud))
-;if(pud_none(*pud))break;if(pud_bad(*pud)){printk("\x28\x62\x61\x64\x29");break;
-}pmd=pmd_offset(pud,addr);if(PTRS_PER_PMD!=(0x2f2+3649-0x1132))printk(
-"\x2c\x20\x2a\x70\x6d\x64\x3d\x25\x30\x38\x6c\x6c\x78",(long long)pmd_val(*pmd))
-;if(pmd_none(*pmd))break;if(pmd_bad(*pmd)){printk("\x28\x62\x61\x64\x29");break;
-}if(PageHighMem(pfn_to_page(pmd_val(*pmd)>>PAGE_SHIFT)))break;pte=pte_offset_map
-(pmd,addr);printk("\x2c\x20\x2a\x70\x74\x65\x3d\x25\x30\x38\x6c\x6c\x78",(long
-long)pte_val(*pte));
-#ifndef CONFIG_ARM_LPAE
-printk("\x2c\x20\x2a\x70\x70\x74\x65\x3d\x25\x30\x38\x6c\x6c\x78",(long long)
-pte_val(pte[PTE_HWTABLE_PTRS]));
-#endif
-pte_unmap(pte);}while((0xd42+2541-0x172f));printk("\n");}
-#else
-void show_pte(struct mm_struct*mm,unsigned long addr){}
-#endif
-static void __do_kernel_fault(struct mm_struct*mm,unsigned long addr,unsigned
-int fsr,struct pt_regs*regs){if(fixup_exception(regs))return;bust_spinlocks(
-(0xc15+4433-0x1d65));printk(KERN_ALERT
-"\x55\x6e\x61\x62\x6c\x65\x20\x74\x6f\x20\x68\x61\x6e\x64\x6c\x65\x20\x6b\x65\x72\x6e\x65\x6c\x20\x25\x73\x20\x61\x74\x20\x76\x69\x72\x74\x75\x61\x6c\x20\x61\x64\x64\x72\x65\x73\x73\x20\x25\x30\x38\x6c\x78" "\n"
-,(addr<PAGE_SIZE)?
-"\x4e\x55\x4c\x4c\x20\x70\x6f\x69\x6e\x74\x65\x72\x20\x64\x65\x72\x65\x66\x65\x72\x65\x6e\x63\x65"
-:"\x70\x61\x67\x69\x6e\x67\x20\x72\x65\x71\x75\x65\x73\x74",addr);show_pte(mm,
-addr);die("\x4f\x6f\x70\x73",regs,fsr);bust_spinlocks((0xd40+5536-0x22e0));
-do_exit(SIGKILL);}static void __do_user_fault(struct task_struct*tsk,unsigned
-long addr,unsigned int fsr,unsigned int sig,int code,struct pt_regs*regs){struct
- siginfo si;
-#ifdef CONFIG_DEBUG_USER
-if(((user_debug&UDBG_SEGV)&&(sig==SIGSEGV))||((user_debug&UDBG_BUS)&&(sig==
-SIGBUS))){printk(KERN_DEBUG
-"\x25\x73\x3a\x20\x75\x6e\x68\x61\x6e\x64\x6c\x65\x64\x20\x70\x61\x67\x65\x20\x66\x61\x75\x6c\x74\x20\x28\x25\x64\x29\x20\x61\x74\x20\x30\x78\x25\x30\x38\x6c\x78\x2c\x20\x63\x6f\x64\x65\x20\x30\x78\x25\x30\x33\x78" "\n"
-,tsk->comm,sig,addr,fsr);show_pte(tsk->mm,addr);show_regs(regs);}
-#endif
-tsk->thread.address=addr;tsk->thread.error_code=fsr;tsk->thread.trap_no=
-(0xbf5+5705-0x2230);si.si_signo=sig;si.si_errno=(0x1d10+1487-0x22df);si.si_code=
-code;si.si_addr=(void __user*)addr;force_sig_info(sig,&si,tsk);}void do_bad_area
-(unsigned long addr,unsigned int fsr,struct pt_regs*regs){struct task_struct*tsk
-=current;struct mm_struct*mm=tsk->active_mm;if(user_mode(regs))__do_user_fault(
-tsk,addr,fsr,SIGSEGV,SEGV_MAPERR,regs);else __do_kernel_fault(mm,addr,fsr,regs);
+static inline int notify_page_fault(struct pt_regs *regs, unsigned int fsr)
+{
+ int ret = 0;
+
+ if (!user_mode(regs)) {
+ /* kprobe_running() needs smp_processor_id() */
+ preempt_disable();
+ if (kprobe_running() && kprobe_fault_handler(regs, fsr))
+ ret = 1;
+ preempt_enable();
+ }
+
+ return ret;
}
-#ifdef CONFIG_MMU
-#define VM_FAULT_BADMAP 65536
-#define VM_FAULT_BADACCESS 131072
-static inline bool access_error(unsigned int fsr,struct vm_area_struct*vma){
-unsigned int mask=VM_READ|VM_WRITE|VM_EXEC;if(fsr&FSR_WRITE)mask=VM_WRITE;if(fsr
-&FSR_LNX_PF)mask=VM_EXEC;return vma->vm_flags&mask?false:true;}static int
-__kprobes __do_page_fault(struct mm_struct*mm,unsigned long addr,unsigned int
-fsr,unsigned int flags,struct task_struct*tsk){struct vm_area_struct*vma;int
-fault;vma=find_vma(mm,addr);fault=VM_FAULT_BADMAP;if(unlikely(!vma))goto out;if(
-unlikely(vma->vm_start>addr))goto check_stack;good_area:if(access_error(fsr,vma)
-){fault=VM_FAULT_BADACCESS;goto out;}return handle_mm_fault(mm,vma,addr&
-PAGE_MASK,flags);check_stack:if(vma->vm_flags&VM_GROWSDOWN&&addr>=
-FIRST_USER_ADDRESS&&!expand_stack(vma,addr))goto good_area;out:return fault;}
-static int __kprobes do_page_fault(unsigned long addr,unsigned int fsr,struct
-pt_regs*regs){struct task_struct*tsk;struct mm_struct*mm;int fault,sig,code;int
-write=fsr&FSR_WRITE;unsigned int flags=FAULT_FLAG_ALLOW_RETRY|
-FAULT_FLAG_KILLABLE|(write?FAULT_FLAG_WRITE:(0x83+6084-0x1847));if(
-notify_page_fault(regs,fsr))return(0x13b6+3139-0x1ff9);tsk=current;mm=tsk->mm;if
-(interrupts_enabled(regs))local_irq_enable();if(!mm||pagefault_disabled())goto
-no_context;if(!down_read_trylock(&mm->mmap_sem)){if(!user_mode(regs)&&!
-search_exception_tables(regs->ARM_pc))goto no_context;retry:down_read(&mm->
-mmap_sem);}else{might_sleep();
-#ifdef CONFIG_DEBUG_VM
-if(!user_mode(regs)&&!search_exception_tables(regs->ARM_pc))goto no_context;
-#endif
-}fault=__do_page_fault(mm,addr,fsr,flags,tsk);if((fault&VM_FAULT_RETRY)&&
-fatal_signal_pending(current))return(0xea5+2777-0x197e);perf_sw_event(
-PERF_COUNT_SW_PAGE_FAULTS,(0x11ef+2350-0x1b1c),regs,addr);if(!(fault&
-VM_FAULT_ERROR)&&flags&FAULT_FLAG_ALLOW_RETRY){if(fault&VM_FAULT_MAJOR){tsk->
-maj_flt++;perf_sw_event(PERF_COUNT_SW_PAGE_FAULTS_MAJ,(0xa32+629-0xca6),regs,
-addr);}else{tsk->min_flt++;perf_sw_event(PERF_COUNT_SW_PAGE_FAULTS_MIN,
-(0x11a1+4424-0x22e8),regs,addr);}if(fault&VM_FAULT_RETRY){flags&=~
-FAULT_FLAG_ALLOW_RETRY;goto retry;}}up_read(&mm->mmap_sem);if(likely(!(fault&(
-VM_FAULT_ERROR|VM_FAULT_BADMAP|VM_FAULT_BADACCESS))))return(0x143c+1796-0x1b40);
-if(fault&VM_FAULT_OOM){pagefault_out_of_memory();return(0x600+3648-0x1440);}if(!
-user_mode(regs))goto no_context;if(fault&VM_FAULT_SIGBUS){sig=SIGBUS;code=
-BUS_ADRERR;}else{sig=SIGSEGV;code=fault==VM_FAULT_BADACCESS?SEGV_ACCERR:
-SEGV_MAPERR;}__do_user_fault(tsk,addr,fsr,sig,code,regs);return
-(0xac0+3527-0x1887);no_context:__do_kernel_fault(mm,addr,fsr,regs);return
-(0x191a+3158-0x2570);}
-#else
-static int do_page_fault(unsigned long addr,unsigned int fsr,struct pt_regs*regs
-){return(0x255+6734-0x1ca3);}
-#endif
-#ifdef CONFIG_MMU
-static int __kprobes do_translation_fault(unsigned long addr,unsigned int fsr,
-struct pt_regs*regs){unsigned int index;pgd_t*pgd,*pgd_k;pud_t*pud,*pud_k;pmd_t*
-pmd,*pmd_k;if(addr<TASK_SIZE)return do_page_fault(addr,fsr,regs);if(
-interrupts_enabled(regs))local_irq_enable();if(user_mode(regs))goto bad_area;
-index=pgd_index(addr);pgd=cpu_get_pgd()+index;pgd_k=init_mm.pgd+index;if(
-pgd_none(*pgd_k))goto bad_area;if(!pgd_present(*pgd))set_pgd(pgd,*pgd_k);pud=
-pud_offset(pgd,addr);pud_k=pud_offset(pgd_k,addr);if(pud_none(*pud_k))goto
-bad_area;if(!pud_present(*pud))set_pud(pud,*pud_k);pmd=pmd_offset(pud,addr);
-pmd_k=pmd_offset(pud_k,addr);
-#ifdef CONFIG_ARM_LPAE
-index=(0xeef+6127-0x26de);
#else
-index=(addr>>SECTION_SHIFT)&(0x6e5+1582-0xd12);
+static inline int notify_page_fault(struct pt_regs *regs, unsigned int fsr)
+{
+ return 0;
+}
#endif
-if(pmd_none(pmd_k[index]))goto bad_area;copy_pmd(pmd,pmd_k);return
-(0x1722+1498-0x1cfc);bad_area:do_bad_area(addr,fsr,regs);return
-(0x1cba+276-0x1dce);}
-#else
-static int do_translation_fault(unsigned long addr,unsigned int fsr,struct
-pt_regs*regs){return(0x163f+815-0x196e);}
-#endif
-static int do_sect_fault(unsigned long addr,unsigned int fsr,struct pt_regs*regs
-){if(interrupts_enabled(regs))local_irq_enable();do_bad_area(addr,fsr,regs);
-return(0x11f9+1016-0x15f1);}static int do_bad(unsigned long addr,unsigned int
-fsr,struct pt_regs*regs){return(0x461+8053-0x23d5);}struct fsr_info{int(*fn)(
-unsigned long addr,unsigned int fsr,struct pt_regs*regs);int sig;int code;const
-char*name;};
+
+/*
+ * This is useful to dump out the page tables associated with
+ * 'addr' in mm 'mm'.
+ */
+void show_pte(struct mm_struct *mm, unsigned long addr)
+{
+ pgd_t *pgd;
+
+ if (!mm)
+ mm = &init_mm;
+
+ printk(KERN_ALERT "pgd = %p\n", mm->pgd);
+ pgd = pgd_offset(mm, addr);
+ printk(KERN_ALERT "[%08lx] *pgd=%08llx",
+ addr, (long long)pgd_val(*pgd));
+
+ do {
+ pud_t *pud;
+ pmd_t *pmd;
+ pte_t *pte;
+
+ if (pgd_none(*pgd))
+ break;
+
+ if (pgd_bad(*pgd)) {
+ printk("(bad)");
+ break;
+ }
+
+ pud = pud_offset(pgd, addr);
+ if (PTRS_PER_PUD != 1)
+ printk(", *pud=%08llx", (long long)pud_val(*pud));
+
+ if (pud_none(*pud))
+ break;
+
+ if (pud_bad(*pud)) {
+ printk("(bad)");
+ break;
+ }
+
+ pmd = pmd_offset(pud, addr);
+ if (PTRS_PER_PMD != 1)
+ printk(", *pmd=%08llx", (long long)pmd_val(*pmd));
+
+ if (pmd_none(*pmd))
+ break;
+
+ if (pmd_bad(*pmd)) {
+ printk("(bad)");
+ break;
+ }
+
+ /* We must not map this if we have highmem enabled */
+ if (PageHighMem(pfn_to_page(pmd_val(*pmd) >> PAGE_SHIFT)))
+ break;
+
+ pte = pte_offset_map(pmd, addr);
+ printk(", *pte=%08llx", (long long)pte_val(*pte));
+#ifndef CONFIG_ARM_LPAE
+ printk(", *ppte=%08llx",
+ (long long)pte_val(pte[PTE_HWTABLE_PTRS]));
+#endif
+ pte_unmap(pte);
+ } while(0);
+
+ printk("\n");
+}
+#else /* CONFIG_MMU */
+void show_pte(struct mm_struct *mm, unsigned long addr)
+{ }
+#endif /* CONFIG_MMU */
+
+/*
+ * Oops. The kernel tried to access some page that wasn't present.
+ */
+static void
+__do_kernel_fault(struct mm_struct *mm, unsigned long addr, unsigned int fsr,
+ struct pt_regs *regs)
+{
+ /*
+ * Are we prepared to handle this kernel fault?
+ */
+ if (fixup_exception(regs))
+ return;
+
+ /*
+ * No handler, we'll have to terminate things with extreme prejudice.
+ */
+ bust_spinlocks(1);
+ printk(KERN_ALERT
+ "Unable to handle kernel %s at virtual address %08lx\n",
+ (addr < PAGE_SIZE) ? "NULL pointer dereference" :
+ "paging request", addr);
+
+ show_pte(mm, addr);
+ die("Oops", regs, fsr);
+ bust_spinlocks(0);
+ do_exit(SIGKILL);
+}
+
+/*
+ * Something tried to access memory that isn't in our memory map..
+ * User mode accesses just cause a SIGSEGV
+ */
+static void
+__do_user_fault(struct task_struct *tsk, unsigned long addr,
+ unsigned int fsr, unsigned int sig, int code,
+ struct pt_regs *regs)
+{
+ struct siginfo si;
+
+#ifdef CONFIG_DEBUG_USER
+ if (((user_debug & UDBG_SEGV) && (sig == SIGSEGV)) ||
+ ((user_debug & UDBG_BUS) && (sig == SIGBUS))) {
+ printk(KERN_DEBUG "%s: unhandled page fault (%d) at 0x%08lx, code 0x%03x\n",
+ tsk->comm, sig, addr, fsr);
+ show_pte(tsk->mm, addr);
+ show_regs(regs);
+ }
+#endif
+
+ tsk->thread.address = addr;
+ tsk->thread.error_code = fsr;
+ tsk->thread.trap_no = 14;
+ si.si_signo = sig;
+ si.si_errno = 0;
+ si.si_code = code;
+ si.si_addr = (void __user *)addr;
+ force_sig_info(sig, &si, tsk);
+}
+
+void do_bad_area(unsigned long addr, unsigned int fsr, struct pt_regs *regs)
+{
+ struct task_struct *tsk = current;
+ struct mm_struct *mm = tsk->active_mm;
+
+ /*
+ * If we are in kernel mode at this point, we
+ * have no context to handle this fault with.
+ */
+ if (user_mode(regs))
+ __do_user_fault(tsk, addr, fsr, SIGSEGV, SEGV_MAPERR, regs);
+ else
+ __do_kernel_fault(mm, addr, fsr, regs);
+}
+
+#ifdef CONFIG_MMU
+#define VM_FAULT_BADMAP 0x010000
+#define VM_FAULT_BADACCESS 0x020000
+
+/*
+ * Check that the permissions on the VMA allow for the fault which occurred.
+ * If we encountered a write fault, we must have write permission, otherwise
+ * we allow any permission.
+ */
+static inline bool access_error(unsigned int fsr, struct vm_area_struct *vma)
+{
+ unsigned int mask = VM_READ | VM_WRITE | VM_EXEC;
+
+ if (fsr & FSR_WRITE)
+ mask = VM_WRITE;
+ if (fsr & FSR_LNX_PF)
+ mask = VM_EXEC;
+
+ return vma->vm_flags & mask ? false : true;
+}
+
+static int __kprobes
+__do_page_fault(struct mm_struct *mm, unsigned long addr, unsigned int fsr,
+ unsigned int flags, struct task_struct *tsk)
+{
+ struct vm_area_struct *vma;
+ int fault;
+
+ vma = find_vma(mm, addr);
+ fault = VM_FAULT_BADMAP;
+ if (unlikely(!vma))
+ goto out;
+ if (unlikely(vma->vm_start > addr))
+ goto check_stack;
+
+ /*
+ * Ok, we have a good vm_area for this
+ * memory access, so we can handle it.
+ */
+good_area:
+ if (access_error(fsr, vma)) {
+ fault = VM_FAULT_BADACCESS;
+ goto out;
+ }
+
+ return handle_mm_fault(mm, vma, addr & PAGE_MASK, flags);
+
+check_stack:
+ /* Don't allow expansion below FIRST_USER_ADDRESS */
+ if (vma->vm_flags & VM_GROWSDOWN &&
+ addr >= FIRST_USER_ADDRESS && !expand_stack(vma, addr))
+ goto good_area;
+out:
+ return fault;
+}
+
+static int __kprobes
+do_page_fault(unsigned long addr, unsigned int fsr, struct pt_regs *regs)
+{
+ struct task_struct *tsk;
+ struct mm_struct *mm;
+ int fault, sig, code;
+ int write = fsr & FSR_WRITE;
+ unsigned int flags = FAULT_FLAG_ALLOW_RETRY | FAULT_FLAG_KILLABLE |
+ (write ? FAULT_FLAG_WRITE : 0);
+
+ if (notify_page_fault(regs, fsr))
+ return 0;
+
+ tsk = current;
+ mm = tsk->mm;
+
+ /* Enable interrupts if they were enabled in the parent context. */
+ if (interrupts_enabled(regs))
+ local_irq_enable();
+
+ /*
+ * If we're in an interrupt or have no user
+ * context, we must not take the fault..
+ */
+ if (!mm || pagefault_disabled())
+ goto no_context;
+
+ /*
+ * As per x86, we may deadlock here. However, since the kernel only
+ * validly references user space from well defined areas of the code,
+ * we can bug out early if this is from code which shouldn't.
+ */
+ if (!down_read_trylock(&mm->mmap_sem)) {
+ if (!user_mode(regs) && !search_exception_tables(regs->ARM_pc))
+ goto no_context;
+retry:
+ down_read(&mm->mmap_sem);
+ } else {
+ /*
+ * The above down_read_trylock() might have succeeded in
+ * which case, we'll have missed the might_sleep() from
+ * down_read()
+ */
+ might_sleep();
+#ifdef CONFIG_DEBUG_VM
+ if (!user_mode(regs) &&
+ !search_exception_tables(regs->ARM_pc))
+ goto no_context;
+#endif
+ }
+
+ fault = __do_page_fault(mm, addr, fsr, flags, tsk);
+
+ /* If we need to retry but a fatal signal is pending, handle the
+ * signal first. We do not need to release the mmap_sem because
+ * it would already be released in __lock_page_or_retry in
+ * mm/filemap.c. */
+ if ((fault & VM_FAULT_RETRY) && fatal_signal_pending(current))
+ return 0;
+
+ /*
+ * Major/minor page fault accounting is only done on the
+ * initial attempt. If we go through a retry, it is extremely
+ * likely that the page will be found in page cache at that point.
+ */
+
+ perf_sw_event(PERF_COUNT_SW_PAGE_FAULTS, 1, regs, addr);
+ if (!(fault & VM_FAULT_ERROR) && flags & FAULT_FLAG_ALLOW_RETRY) {
+ if (fault & VM_FAULT_MAJOR) {
+ tsk->maj_flt++;
+ perf_sw_event(PERF_COUNT_SW_PAGE_FAULTS_MAJ, 1,
+ regs, addr);
+ } else {
+ tsk->min_flt++;
+ perf_sw_event(PERF_COUNT_SW_PAGE_FAULTS_MIN, 1,
+ regs, addr);
+ }
+ if (fault & VM_FAULT_RETRY) {
+ /* Clear FAULT_FLAG_ALLOW_RETRY to avoid any risk
+ * of starvation. */
+ flags &= ~FAULT_FLAG_ALLOW_RETRY;
+ goto retry;
+ }
+ }
+
+ up_read(&mm->mmap_sem);
+
+ /*
+ * Handle the "normal" case first - VM_FAULT_MAJOR / VM_FAULT_MINOR
+ */
+ if (likely(!(fault & (VM_FAULT_ERROR | VM_FAULT_BADMAP | VM_FAULT_BADACCESS))))
+ return 0;
+
+ if (fault & VM_FAULT_OOM) {
+ /*
+ * We ran out of memory, call the OOM killer, and return to
+ * userspace (which will retry the fault, or kill us if we
+ * got oom-killed)
+ */
+ pagefault_out_of_memory();
+ return 0;
+ }
+
+ /*
+ * If we are in kernel mode at this point, we
+ * have no context to handle this fault with.
+ */
+ if (!user_mode(regs))
+ goto no_context;
+
+ if (fault & VM_FAULT_SIGBUS) {
+ /*
+ * We had some memory, but were unable to
+ * successfully fix up this page fault.
+ */
+ sig = SIGBUS;
+ code = BUS_ADRERR;
+ } else {
+ /*
+ * Something tried to access memory that
+ * isn't in our memory map..
+ */
+ sig = SIGSEGV;
+ code = fault == VM_FAULT_BADACCESS ?
+ SEGV_ACCERR : SEGV_MAPERR;
+ }
+
+ __do_user_fault(tsk, addr, fsr, sig, code, regs);
+ return 0;
+
+no_context:
+ __do_kernel_fault(mm, addr, fsr, regs);
+ return 0;
+}
+#else /* CONFIG_MMU */
+static int
+do_page_fault(unsigned long addr, unsigned int fsr, struct pt_regs *regs)
+{
+ return 0;
+}
+#endif /* CONFIG_MMU */
+
+/*
+ * First Level Translation Fault Handler
+ *
+ * We enter here because the first level page table doesn't contain
+ * a valid entry for the address.
+ *
+ * If the address is in kernel space (>= TASK_SIZE), then we are
+ * probably faulting in the vmalloc() area.
+ *
+ * If the init_task's first level page tables contains the relevant
+ * entry, we copy the it to this task. If not, we send the process
+ * a signal, fixup the exception, or oops the kernel.
+ *
+ * NOTE! We MUST NOT take any locks for this case. We may be in an
+ * interrupt or a critical region, and should only copy the information
+ * from the master page table, nothing more.
+ */
+#ifdef CONFIG_MMU
+static int __kprobes
+do_translation_fault(unsigned long addr, unsigned int fsr,
+ struct pt_regs *regs)
+{
+ unsigned int index;
+ pgd_t *pgd, *pgd_k;
+ pud_t *pud, *pud_k;
+ pmd_t *pmd, *pmd_k;
+
+ if (addr < TASK_SIZE)
+ return do_page_fault(addr, fsr, regs);
+
+ if (interrupts_enabled(regs))
+ local_irq_enable();
+
+ if (user_mode(regs))
+ goto bad_area;
+
+ index = pgd_index(addr);
+
+ /*
+ * FIXME: CP15 C1 is write only on ARMv3 architectures.
+ */
+ pgd = cpu_get_pgd() + index;
+ pgd_k = init_mm.pgd + index;
+
+ if (pgd_none(*pgd_k))
+ goto bad_area;
+ if (!pgd_present(*pgd))
+ set_pgd(pgd, *pgd_k);
+
+ pud = pud_offset(pgd, addr);
+ pud_k = pud_offset(pgd_k, addr);
+
+ if (pud_none(*pud_k))
+ goto bad_area;
+ if (!pud_present(*pud))
+ set_pud(pud, *pud_k);
+
+ pmd = pmd_offset(pud, addr);
+ pmd_k = pmd_offset(pud_k, addr);
+
+#ifdef CONFIG_ARM_LPAE
+ /*
+ * Only one hardware entry per PMD with LPAE.
+ */
+ index = 0;
+#else
+ /*
+ * On ARM one Linux PGD entry contains two hardware entries (see page
+ * tables layout in pgtable.h). We normally guarantee that we always
+ * fill both L1 entries. But create_mapping() doesn't follow the rule.
+ * It can create inidividual L1 entries, so here we have to call
+ * pmd_none() check for the entry really corresponded to address, not
+ * for the first of pair.
+ */
+ index = (addr >> SECTION_SHIFT) & 1;
+#endif
+ if (pmd_none(pmd_k[index]))
+ goto bad_area;
+
+ copy_pmd(pmd, pmd_k);
+ return 0;
+
+bad_area:
+ do_bad_area(addr, fsr, regs);
+ return 0;
+}
+#else /* CONFIG_MMU */
+static int
+do_translation_fault(unsigned long addr, unsigned int fsr,
+ struct pt_regs *regs)
+{
+ return 0;
+}
+#endif /* CONFIG_MMU */
+
+/*
+ * Some section permission faults need to be handled gracefully.
+ * They can happen due to a __{get,put}_user during an oops.
+ */
+static int
+do_sect_fault(unsigned long addr, unsigned int fsr, struct pt_regs *regs)
+{
+ if (interrupts_enabled(regs))
+ local_irq_enable();
+
+ do_bad_area(addr, fsr, regs);
+ return 0;
+}
+
+/*
+ * This abort handler always returns "fault".
+ */
+static int
+do_bad(unsigned long addr, unsigned int fsr, struct pt_regs *regs)
+{
+ return 1;
+}
+
+struct fsr_info {
+ int (*fn)(unsigned long addr, unsigned int fsr, struct pt_regs *regs);
+ int sig;
+ int code;
+ const char *name;
+};
+
+/* FSR definition */
#ifdef CONFIG_ARM_LPAE
#include "fsr-3level.c"
#else
#include "fsr-2level.c"
#endif
-void __init hook_fault_code(int nr,int(*fn)(unsigned long,unsigned int,struct
-pt_regs*),int sig,int code,const char*name){if(nr<(0xce5+4250-0x1d7f)||nr>=
-ARRAY_SIZE(fsr_info))BUG();fsr_info[nr].fn=fn;fsr_info[nr].sig=sig;fsr_info[nr].
-code=code;fsr_info[nr].name=name;}
+
+void __init
+hook_fault_code(int nr, int (*fn)(unsigned long, unsigned int, struct pt_regs *),
+ int sig, int code, const char *name)
+{
+ if (nr < 0 || nr >= ARRAY_SIZE(fsr_info))
+ BUG();
+
+ fsr_info[nr].fn = fn;
+ fsr_info[nr].sig = sig;
+ fsr_info[nr].code = code;
+ fsr_info[nr].name = name;
+}
+
#ifdef CONFIG_MODEM_CODE_IS_MAPPING
-static DECLARE_RWSEM(shrinker_rwsem);atomic_t _code_page_count=ATOMIC_INIT(
-(0x64c+3281-0x131d));struct addr_info{struct list_head node;unsigned long vaddr;
-unsigned long kaddr;unsigned long page_index;};enum modem_access_technology{GSM=
-(0x42f+2882-0xf71),UTRAN=(0x1869+204-0x1934),LTE=(0x1735+1609-0x1d7c),COM=
-(0x788+3773-0x1642),NR_MODEM_ACCESS=(0x4b8+5810-0x1b66)};struct list_head
-modem_page_list[NR_MODEM_ACCESS]={LIST_HEAD_INIT(modem_page_list[
-(0x5e7+4772-0x188b)]),LIST_HEAD_INIT(modem_page_list[(0xa89+6078-0x2246)]),
-LIST_HEAD_INIT(modem_page_list[(0x3ad+8939-0x2696)]),LIST_HEAD_INIT(
-modem_page_list[(0x19c3+1240-0x1e98)]),};unsigned int page_used[
-(0x195d+2789-0x241a)];struct completion page_completion[(0x51f+748-0x7e3)*
-(0x42f+1562-0xa29)];static void unmap_pte_range(pmd_t*pmd,unsigned long addr,
-unsigned long end){pte_t*pte;pte=pte_offset_kernel(pmd,addr);do{pte_t ptent=
-ptep_get_and_clear(&init_mm,addr,pte);WARN_ON(!pte_none(ptent)&&!pte_present(
-ptent));}while(pte++,addr+=PAGE_SIZE,addr!=end);}static void unmap_pmd_range(
-pud_t*pud,unsigned long addr,unsigned long end){pmd_t*pmd;unsigned long next;pmd
-=pmd_offset(pud,addr);do{next=pmd_addr_end(addr,end);if(pmd_none_or_clear_bad(
-pmd))continue;unmap_pte_range(pmd,addr,next);}while(pmd++,addr=next,addr!=end);}
-static void unmap_pud_range(pgd_t*pgd,unsigned long addr,unsigned long end){
-pud_t*pud;unsigned long next;pud=pud_offset(pgd,addr);do{next=pud_addr_end(addr,
-end);if(pud_none_or_clear_bad(pud))continue;unmap_pmd_range(pud,addr,next);}
-while(pud++,addr=next,addr!=end);}static void unmap_page_range(unsigned long
-addr,unsigned long end){pgd_t*pgd;unsigned long next;BUG_ON(addr>=end);pgd=
-pgd_offset_k(addr);do{next=pgd_addr_end(addr,end);if(pgd_none_or_clear_bad(pgd))
-continue;unmap_pud_range(pgd,addr,next);}while(pgd++,addr=next,addr!=end);}void
-shrink_modem_mem(unsigned int access_type){int i=(0xfc2+581-0x1207);unsigned
-long vaddr;struct addr_info*addr,*tmp_addr;struct list_head tmp_page_list;for(i=
-(0x5eb+4111-0x15fa);i<NR_MODEM_ACCESS;i++){if(i==access_type)continue;down_write
-(&shrinker_rwsem);list_replace_init(&modem_page_list[i],&tmp_page_list);up_write
-(&shrinker_rwsem);list_for_each_entry_safe(addr,tmp_addr,&tmp_page_list,node){
-list_del_init(&addr->node);page_completion[addr->page_index].done=
-(0x187+7014-0x1ced);page_used[addr->page_index/BITS_PER_LONG]&=~(
-(0x1b0a+2503-0x24d0)<<(addr->page_index%BITS_PER_LONG));vaddr=addr->vaddr&
-PAGE_MASK;if(vaddr<cpps_global_var.cpko_text_start||vaddr>cpps_global_var.
-modem_text_end){panic(
-"\x61\x64\x64\x72\x5f\x69\x6e\x66\x6f\x3a\x20\x25\x30\x38\x78\x20\x69\x73\x20\x20\x64\x65\x73\x74\x72\x6f\x79"
-,addr);}flush_cache_vunmap(vaddr,vaddr+PAGE_SIZE);unmap_page_range(vaddr,vaddr+
-PAGE_SIZE);flush_tlb_kernel_range(vaddr,vaddr+PAGE_SIZE);
+//#define __codetext __attribute__((__section__(".modem.text")))
+
+static DECLARE_RWSEM(shrinker_rwsem);
+atomic_t _code_page_count = ATOMIC_INIT(0);
+
+struct addr_info{
+ struct list_head node;
+ unsigned long vaddr;
+ unsigned long kaddr;
+ unsigned long page_index;
+};
+
+enum modem_access_technology {
+ GSM = 0,
+ UTRAN = 1,
+ LTE = 2,
+ COM = 3,
+ NR_MODEM_ACCESS =4
+};
+struct list_head modem_page_list[NR_MODEM_ACCESS] ={
+ LIST_HEAD_INIT(modem_page_list[0]),
+ LIST_HEAD_INIT(modem_page_list[1]),
+ LIST_HEAD_INIT(modem_page_list[2]),
+ LIST_HEAD_INIT(modem_page_list[3]),
+};
+
+unsigned int page_used[40];
+struct completion page_completion[40*32];
+
+static void unmap_pte_range(pmd_t *pmd, unsigned long addr, unsigned long end)
+{
+ pte_t *pte;
+
+ pte = pte_offset_kernel(pmd, addr);
+ do {
+ pte_t ptent = ptep_get_and_clear(&init_mm, addr, pte);
+ WARN_ON(!pte_none(ptent) && !pte_present(ptent));
+ } while (pte++, addr += PAGE_SIZE, addr != end);
+}
+
+static void unmap_pmd_range(pud_t *pud, unsigned long addr, unsigned long end)
+{
+ pmd_t *pmd;
+ unsigned long next;
+
+ pmd = pmd_offset(pud, addr);
+ do {
+ next = pmd_addr_end(addr, end);
+ if (pmd_none_or_clear_bad(pmd))
+ continue;
+ unmap_pte_range(pmd, addr, next);
+ } while (pmd++, addr = next, addr != end);
+}
+
+static void unmap_pud_range(pgd_t *pgd, unsigned long addr, unsigned long end)
+{
+ pud_t *pud;
+ unsigned long next;
+
+ pud = pud_offset(pgd, addr);
+ do {
+ next = pud_addr_end(addr, end);
+ if (pud_none_or_clear_bad(pud))
+ continue;
+ unmap_pmd_range(pud, addr, next);
+ } while (pud++, addr = next, addr != end);
+}
+
+static void unmap_page_range(unsigned long addr, unsigned long end)
+{
+ pgd_t *pgd;
+ unsigned long next;
+
+ BUG_ON(addr >= end);
+ pgd = pgd_offset_k(addr);
+ do {
+ next = pgd_addr_end(addr, end);
+ if (pgd_none_or_clear_bad(pgd))
+ continue;
+ unmap_pud_range(pgd, addr, next);
+ } while (pgd++, addr = next, addr != end);
+}
+
+void shrink_modem_mem(unsigned int access_type)
+{
+ int i = 0;
+ unsigned long vaddr;
+ struct addr_info *addr, *tmp_addr;
+ struct list_head tmp_page_list;
+
+ for (i= 0; i < NR_MODEM_ACCESS; i++) {
+ if (i == access_type)
+ continue;
+
+ down_write(&shrinker_rwsem);
+ list_replace_init(&modem_page_list[i],&tmp_page_list);
+ up_write(&shrinker_rwsem);
+ list_for_each_entry_safe(addr, tmp_addr, &tmp_page_list, node) {
+ list_del_init(&addr->node);
+ page_completion[addr->page_index].done = 0;
+ page_used[addr->page_index/BITS_PER_LONG] &= ~(1 << (addr->page_index % BITS_PER_LONG));
+ vaddr = addr->vaddr & PAGE_MASK;
+ if(vaddr < cpps_global_var.cpko_text_start || vaddr > cpps_global_var.modem_text_end){
+ panic("addr_info: %08x is destroy",addr);
+ }
+ flush_cache_vunmap(vaddr, vaddr + PAGE_SIZE);
+ unmap_page_range(vaddr, vaddr + PAGE_SIZE);
+ flush_tlb_kernel_range(vaddr, vaddr + PAGE_SIZE);
#ifdef CONFIG_DEBUG_RODATA
-unsigned int flags;local_irq_save(flags);set_memory_rw(addr->kaddr,
-(0x4a0+48-0x4cf));local_irq_restore(flags);
+ unsigned int flags;
+ local_irq_save(flags);
+ set_memory_rw(addr->kaddr,1);
+ local_irq_restore(flags);
#endif
-free_page(addr->kaddr);kfree(addr);atomic_dec(&_code_page_count);};}}
-EXPORT_SYMBOL(shrink_modem_mem);phys_addr_t virt_is_mapping(unsigned long addr){
-pgd_t*pgd;pmd_t*pmd;pte_t*ptep,pte;unsigned long pfn;pgd=pgd_offset_k(addr);if(!
-pgd_none(*pgd)){pmd=pmd_offset(pgd,addr);if(!pmd_none(*pmd)){ptep=pte_offset_map
-(pmd,addr);pte=*ptep;if(pte_present(pte)){pfn=pte_pfn(pte);return __pfn_to_phys(
-pfn);}}}return(0x9d4+475-0xbaf);}static int sync_pgd(unsigned long addr,unsigned
- int fsr,struct pt_regs*regs){unsigned int index;pgd_t*pgd,*pgd_k;pud_t*pud,*
-pud_k;pmd_t*pmd,*pmd_k;index=pgd_index(addr);pgd=cpu_get_pgd()+index;pgd_k=
-init_mm.pgd+index;if(pgd_none(*pgd_k))goto bad_area;if(!pgd_present(*pgd))
-set_pgd(pgd,*pgd_k);pud=pud_offset(pgd,addr);pud_k=pud_offset(pgd_k,addr);if(
-pud_none(*pud_k))goto bad_area;if(!pud_present(*pud))set_pud(pud,*pud_k);pmd=
-pmd_offset(pud,addr);pmd_k=pmd_offset(pud_k,addr);
-#ifdef CONFIG_ARM_LPAE
-index=(0x9fd+4051-0x19d0);
+ free_page(addr->kaddr);
+ kfree(addr);
+
+ atomic_dec(&_code_page_count);/*after reclaim ,need modify this*/
+ };
+
+ }
+}
+EXPORT_SYMBOL(shrink_modem_mem);
+phys_addr_t virt_is_mapping(unsigned long addr)
+{
+ pgd_t *pgd;
+ pmd_t *pmd;
+ pte_t *ptep, pte;
+ unsigned long pfn;
+
+ /* check whether we found an entry */
+ pgd = pgd_offset_k(addr);
+
+ if(!pgd_none(*pgd)) {
+ /* get the page middle directory */
+ pmd = pmd_offset(pgd, addr);
+ /* check for a valid entry */
+ if(!pmd_none(*pmd)) {
+ /* get a pointer to the page table entry */
+ ptep = pte_offset_map(pmd, addr);
+ /* get the page table entry itself */
+ pte = *ptep;
+ if (pte_present(pte)) {
+ //ptr_page = pte_page(pte);
+ pfn = pte_pfn(pte);
+ //pte_unmap(ptep);
+ return __pfn_to_phys(pfn);
+ }
+ /* check for a valid page */
+ }
+ }
+ return 0;
+}
+
+static int sync_pgd(unsigned long addr, unsigned int fsr,
+ struct pt_regs *regs)
+{
+ unsigned int index;
+ pgd_t *pgd, *pgd_k;
+ pud_t *pud, *pud_k;
+ pmd_t *pmd, *pmd_k;
+ index = pgd_index(addr);
+
+ /*
+ * FIXME: CP15 C1 is write only on ARMv3 architectures.
+ */
+ pgd = cpu_get_pgd() + index;
+ pgd_k = init_mm.pgd + index;
+
+ if (pgd_none(*pgd_k))
+ goto bad_area;
+ if (!pgd_present(*pgd))
+ set_pgd(pgd, *pgd_k);
+
+ pud = pud_offset(pgd, addr);
+ pud_k = pud_offset(pgd_k, addr);
+
+ if (pud_none(*pud_k))
+ goto bad_area;
+ if (!pud_present(*pud))
+ set_pud(pud, *pud_k);
+
+ pmd = pmd_offset(pud, addr);
+ pmd_k = pmd_offset(pud_k, addr);
+
+ #ifdef CONFIG_ARM_LPAE
+ /*
+ * Only one hardware entry per PMD with LPAE.
+ */
+ index = 0;
#else
-index=(addr>>SECTION_SHIFT)&(0x1525+1755-0x1bff);
+ /*
+ * On ARM one Linux PGD entry contains two hardware entries (see page
+ * tables layout in pgtable.h). We normally guarantee that we always
+ * fill both L1 entries. But create_mapping() doesn't follow the rule.
+ * It can create inidividual L1 entries, so here we have to call
+ * pmd_none() check for the entry really corresponded to address, not
+ * for the first of pair.
+ */
+ index = (addr >> SECTION_SHIFT) & 1;
#endif
-if(pmd_none(pmd_k[index]))goto bad_area;copy_pmd(pmd,pmd_k);return
-(0x222+5515-0x17ad);bad_area:do_bad_area(addr,fsr,regs);return(0x5a9+1791-0xca8)
-;}unsigned long*read_code_file(unsigned long page_index){unsigned long*code_buf;
-ssize_t result;code_buf=get_zeroed_page(GFP_ATOMIC);if(!code_buf)panic(
-"\x6d\x65\x6d\x65\x6f\x72\x79\x20\x6e\x6f\x74\x20\x65\x6e\x6f\x75\x67\x68\x21\x21"
-);atomic_inc(&_code_page_count);if(IS_ERR(cpps_global_var.fp_code)||
-cpps_global_var.fp_code==NULL){panic(
-"\x6f\x70\x65\x6e\x20\x66\x69\x6c\x65\x20\x65\x72\x72\x6f\x72" "\n");}
-mm_segment_t old_fs;old_fs=get_fs();set_fs(KERNEL_DS);loff_t pos;pos=page_index*
-PAGE_SIZE+cpps_global_var.modem_offset;result=vfs_read(cpps_global_var.fp_code,(
-char*)code_buf,PAGE_SIZE,&pos);if(result<(0x261d+202-0x26e7)){panic(
-"\x72\x65\x61\x64\x20\x63\x6f\x64\x65\x20\x66\x69\x6c\x65\x20\x65\x72\x72\x6f\x72" "\n"
-);}
+ if (pmd_none(pmd_k[index]))
+ goto bad_area;
+ copy_pmd(pmd, pmd_k);
+ return 0;
+bad_area:
+ do_bad_area(addr, fsr, regs);
+ return 0;
+}
+
+unsigned long* read_code_file(unsigned long page_index)
+{
+ unsigned long* code_buf;
+ ssize_t result;
+ code_buf = get_zeroed_page(GFP_ATOMIC);
+ if(!code_buf)
+ panic("memeory not enough!!");
+ atomic_inc(&_code_page_count);/*after reclaim ,need modify this*/
+
+ if(IS_ERR(cpps_global_var.fp_code) || cpps_global_var.fp_code == NULL) {
+ panic("open file error\n");
+ }
+ mm_segment_t old_fs;
+ old_fs = get_fs();
+ set_fs(KERNEL_DS);
+ loff_t pos;
+ pos = page_index * PAGE_SIZE + cpps_global_var.modem_offset;
+ result = vfs_read(cpps_global_var.fp_code, (char *)code_buf, PAGE_SIZE, &pos);
+ if(result < 0){
+ panic("read code file error\n");
+ }
#ifdef CONFIG_DEBUG_RODATA
-unsigned int flags;local_irq_save(flags);set_memory_ro((unsigned long)code_buf,
-(0x14db+4276-0x258e));local_irq_restore(flags);
+ unsigned int flags;
+ local_irq_save(flags);
+ set_memory_ro((unsigned long)code_buf,1);
+ local_irq_restore(flags);
#endif
-set_fs(old_fs);return code_buf;}void read_code_mapping(unsigned long addr,
-unsigned int fsr,struct pt_regs*regs){unsigned long offset;unsigned long vaddr;
-const struct mem_type*mtype;unsigned long*vir_codebuf;unsigned long page_index;
-unsigned long page_shift;if(virt_is_mapping(addr&PAGE_MASK)!=(0x28c+598-0x4e2)){
-sync_pgd(addr&PAGE_MASK,fsr,regs);return;}vaddr=addr&PAGE_MASK;offset=vaddr&(~
-cpps_global_var.cpko_text_start);page_index=offset>>PAGE_SHIFT;page_shift=
-page_index%BITS_PER_LONG;if((page_used[page_index/BITS_PER_LONG]>>page_shift)&
-(0x4ef+7834-0x2388)){wait_for_completion(&page_completion[page_index]);sync_pgd(
-vaddr,fsr,regs);return;}else page_used[page_index/BITS_PER_LONG]|=(
-(0xf5f+4169-0x1fa7)<<page_shift);local_irq_enable();vir_codebuf=read_code_file(
-page_index);struct addr_info*addr_info;addr_info=kzalloc(sizeof(struct addr_info
-),GFP_KERNEL);addr_info->kaddr=vir_codebuf;addr_info->vaddr=addr;addr_info->
-page_index=page_index;down_write(&shrinker_rwsem);if(vaddr<cpps_global_var.
-__utran_modem_text_start)list_add(&addr_info->node,&modem_page_list[GSM]);else
-if(vaddr<cpps_global_var.__lte_modem_text_start)list_add(&addr_info->node,&
-modem_page_list[UTRAN]);else if(vaddr<cpps_global_var.__comm_modem_text_start)
-list_add(&addr_info->node,&modem_page_list[LTE]);else list_add(&addr_info->node,
-&modem_page_list[COM]);up_write(&shrinker_rwsem);local_irq_disable();mtype=
-get_mem_type(MT_MEMORY);ioremap_page(vaddr,__pa(vir_codebuf),mtype);sync_pgd(
-vaddr,fsr,regs);flush_icache_range(vaddr,vaddr+PAGE_SIZE);if(waitqueue_active(&
-page_completion[page_index].wait))complete_all(&page_completion[page_index]);
-return;}
+ set_fs(old_fs);
+ return code_buf;
+}
+
+void read_code_mapping(unsigned long addr, unsigned int fsr, struct pt_regs *regs)
+{
+ unsigned long offset;
+ unsigned long vaddr;
+ const struct mem_type *mtype;
+ unsigned long* vir_codebuf;
+ unsigned long page_index;
+ unsigned long page_shift;
+
+
+ if(virt_is_mapping(addr & PAGE_MASK) != 0) {
+ sync_pgd(addr & PAGE_MASK, fsr, regs);
+ return;
+ }
+
+ vaddr = addr & PAGE_MASK;
+ offset = vaddr & (~cpps_global_var.cpko_text_start);
+ page_index = offset >> PAGE_SHIFT;
+ page_shift = page_index % BITS_PER_LONG;
+
+ if ((page_used[page_index/BITS_PER_LONG] >> page_shift) & 0x1) {
+ wait_for_completion(&page_completion[page_index]);
+ sync_pgd(vaddr,fsr,regs);
+ return;
+ }
+ else
+ page_used[page_index/BITS_PER_LONG] |= (1 << page_shift);
+
+ local_irq_enable();
+ vir_codebuf = read_code_file(page_index);
+
+ /*add vir_codebuf to every list by address*/
+ struct addr_info *addr_info;
+ addr_info = kzalloc(sizeof(struct addr_info), GFP_KERNEL);
+ addr_info->kaddr = vir_codebuf;
+ addr_info->vaddr= addr;
+ addr_info->page_index = page_index;
+ down_write(&shrinker_rwsem);
+ if(vaddr < cpps_global_var.__utran_modem_text_start)
+ list_add(&addr_info->node, &modem_page_list[GSM]);
+ else if(vaddr < cpps_global_var.__lte_modem_text_start)
+ list_add(&addr_info->node, &modem_page_list[UTRAN]);
+ else if(vaddr < cpps_global_var.__comm_modem_text_start)
+ list_add(&addr_info->node, &modem_page_list[LTE]);
+ else
+ list_add(&addr_info->node, &modem_page_list[COM]);
+
+ up_write(&shrinker_rwsem);
+
+ local_irq_disable();
+ mtype = get_mem_type(MT_MEMORY);
+ ioremap_page(vaddr, __pa(vir_codebuf), mtype);
+ sync_pgd(vaddr, fsr, regs);
+ flush_icache_range(vaddr, vaddr + PAGE_SIZE);
+
+ if (waitqueue_active(&page_completion[page_index].wait))
+ complete_all(&page_completion[page_index]);/*after reclaim ,need clear done*/
+ return;
+}
#endif
-asmlinkage void __exception do_DataAbort(unsigned long addr,unsigned int fsr,
-struct pt_regs*regs){const struct fsr_info*inf=fsr_info+fsr_fs(fsr);struct
-siginfo info;
+/*
+ * Dispatch a data abort to the relevant handler.
+ */
+asmlinkage void __exception
+do_DataAbort(unsigned long addr, unsigned int fsr, struct pt_regs *regs)
+{
+ const struct fsr_info *inf = fsr_info + fsr_fs(fsr);
+ struct siginfo info;
+
#ifdef CONFIG_MODEM_CODE_IS_MAPPING
-if(addr!=(0x2a4+3839-0x11a3)&&addr>=cpps_global_var.cpko_text_start&&addr<=
-cpps_global_var.modem_text_end){read_code_mapping(addr,fsr&~FSR_LNX_PF,regs);
-return;}
-#endif
-if(!inf->fn(addr,fsr&~FSR_LNX_PF,regs))return;printk(KERN_ALERT
-"\x55\x6e\x68\x61\x6e\x64\x6c\x65\x64\x20\x66\x61\x75\x6c\x74\x3a\x20\x25\x73\x20\x28\x30\x78\x25\x30\x33\x78\x29\x20\x61\x74\x20\x30\x78\x25\x30\x38\x6c\x78" "\n"
-,inf->name,fsr,addr);info.si_signo=inf->sig;info.si_errno=(0x1b19+1711-0x21c8);
-info.si_code=inf->code;info.si_addr=(void __user*)addr;arm_notify_die("",regs,&
-info,fsr,(0x1741+937-0x1aea));}void __init hook_ifault_code(int nr,int(*fn)(
-unsigned long,unsigned int,struct pt_regs*),int sig,int code,const char*name){if
-(nr<(0x129+679-0x3d0)||nr>=ARRAY_SIZE(ifsr_info))BUG();ifsr_info[nr].fn=fn;
-ifsr_info[nr].sig=sig;ifsr_info[nr].code=code;ifsr_info[nr].name=name;}
-asmlinkage void __exception do_PrefetchAbort(unsigned long addr,unsigned int
-ifsr,struct pt_regs*regs){const struct fsr_info*inf=ifsr_info+fsr_fs(ifsr);
-struct siginfo info;
-#ifdef CONFIG_MODEM_CODE_IS_MAPPING
-if(addr!=(0x4f8+4535-0x16af)&&addr>=cpps_global_var.cpko_text_start&&addr<=
-cpps_global_var.modem_text_end){read_code_mapping(addr,ifsr|FSR_LNX_PF,regs);
-return;}
-#endif
-if(!inf->fn(addr,ifsr|FSR_LNX_PF,regs))return;printk(KERN_ALERT
-"\x55\x6e\x68\x61\x6e\x64\x6c\x65\x64\x20\x70\x72\x65\x66\x65\x74\x63\x68\x20\x61\x62\x6f\x72\x74\x3a\x20\x25\x73\x20\x28\x30\x78\x25\x30\x33\x78\x29\x20\x61\x74\x20\x30\x78\x25\x30\x38\x6c\x78" "\n"
-,inf->name,ifsr,addr);info.si_signo=inf->sig;info.si_errno=(0x462+8659-0x2635);
-info.si_code=inf->code;info.si_addr=(void __user*)addr;arm_notify_die("",regs,&
-info,ifsr,(0x6fd+655-0x98c));}
-#ifndef CONFIG_ARM_LPAE
-static int __init exceptions_init(void){if(cpu_architecture()>=CPU_ARCH_ARMv6){
-hook_fault_code((0x1609+3919-0x2554),do_translation_fault,SIGSEGV,SEGV_MAPERR,
-"\x49\x2d\x63\x61\x63\x68\x65\x20\x6d\x61\x69\x6e\x74\x65\x6e\x61\x6e\x63\x65\x20\x66\x61\x75\x6c\x74"
-);}if(cpu_architecture()>=CPU_ARCH_ARMv7){hook_fault_code((0xc06+3912-0x1b4b),
-do_bad,SIGSEGV,SEGV_MAPERR,
-"\x73\x65\x63\x74\x69\x6f\x6e\x20\x61\x63\x63\x65\x73\x73\x20\x66\x6c\x61\x67\x20\x66\x61\x75\x6c\x74"
-);hook_fault_code((0xd6b+1748-0x1439),do_bad,SIGSEGV,SEGV_MAPERR,
-"\x73\x65\x63\x74\x69\x6f\x6e\x20\x61\x63\x63\x65\x73\x73\x20\x66\x6c\x61\x67\x20\x66\x61\x75\x6c\x74"
-);}
-#ifdef CONFIG_MODEM_CODE_IS_MAPPING
-int index=(0xaf+2735-0xb5e);for(index=(0xf17+785-0x1228);index<
-(0x3e9+2169-0xc3a)*(0x300+3991-0x1277);index++)init_completion(&page_completion[
-index]);
-#endif
-return(0x715+4575-0x18f4);}arch_initcall(exceptions_init);
+ if(addr != 0 && addr >= cpps_global_var.cpko_text_start && addr <= cpps_global_var.modem_text_end) {
+ read_code_mapping(addr, fsr & ~FSR_LNX_PF, regs);
+ return;
+ }
#endif
+ if (!inf->fn(addr, fsr & ~FSR_LNX_PF, regs))
+ return;
+
+ printk(KERN_ALERT "Unhandled fault: %s (0x%03x) at 0x%08lx\n",
+ inf->name, fsr, addr);
+
+ info.si_signo = inf->sig;
+ info.si_errno = 0;
+ info.si_code = inf->code;
+ info.si_addr = (void __user *)addr;
+ arm_notify_die("", regs, &info, fsr, 0);
+}
+
+void __init
+hook_ifault_code(int nr, int (*fn)(unsigned long, unsigned int, struct pt_regs *),
+ int sig, int code, const char *name)
+{
+ if (nr < 0 || nr >= ARRAY_SIZE(ifsr_info))
+ BUG();
+
+ ifsr_info[nr].fn = fn;
+ ifsr_info[nr].sig = sig;
+ ifsr_info[nr].code = code;
+ ifsr_info[nr].name = name;
+}
+
+asmlinkage void __exception
+do_PrefetchAbort(unsigned long addr, unsigned int ifsr, struct pt_regs *regs)
+{
+ const struct fsr_info *inf = ifsr_info + fsr_fs(ifsr);
+ struct siginfo info;
+
+#ifdef CONFIG_MODEM_CODE_IS_MAPPING
+ if(addr != 0 && addr >= cpps_global_var.cpko_text_start && addr <= cpps_global_var.modem_text_end) {
+ read_code_mapping(addr, ifsr | FSR_LNX_PF, regs);
+ return;
+ }
+
+#endif
+
+ if (!inf->fn(addr, ifsr | FSR_LNX_PF, regs))
+ return;
+
+ printk(KERN_ALERT "Unhandled prefetch abort: %s (0x%03x) at 0x%08lx\n",
+ inf->name, ifsr, addr);
+
+ info.si_signo = inf->sig;
+ info.si_errno = 0;
+ info.si_code = inf->code;
+ info.si_addr = (void __user *)addr;
+ arm_notify_die("", regs, &info, ifsr, 0);
+}
+
+#ifndef CONFIG_ARM_LPAE
+static int __init exceptions_init(void)
+{
+ if (cpu_architecture() >= CPU_ARCH_ARMv6) {
+ hook_fault_code(4, do_translation_fault, SIGSEGV, SEGV_MAPERR,
+ "I-cache maintenance fault");
+ }
+
+ if (cpu_architecture() >= CPU_ARCH_ARMv7) {
+ /*
+ * TODO: Access flag faults introduced in ARMv6K.
+ * Runtime check for 'K' extension is needed
+ */
+ hook_fault_code(3, do_bad, SIGSEGV, SEGV_MAPERR,
+ "section access flag fault");
+ hook_fault_code(6, do_bad, SIGSEGV, SEGV_MAPERR,
+ "section access flag fault");
+ }
+#ifdef CONFIG_MODEM_CODE_IS_MAPPING
+ int index = 0;
+ for(index = 0;index < 40*32;index++)
+ init_completion(&page_completion[index]);
+#endif
+ return 0;
+}
+
+arch_initcall(exceptions_init);
+#endif
diff --git a/ap/os/linux/linux-3.4.x/drivers/cpko/cpko_main.c b/ap/os/linux/linux-3.4.x/drivers/cpko/cpko_main.c
index 0e87019..48e3eaa 100755
--- a/ap/os/linux/linux-3.4.x/drivers/cpko/cpko_main.c
+++ b/ap/os/linux/linux-3.4.x/drivers/cpko/cpko_main.c
@@ -1,4 +1,3 @@
-
#include <linux/module.h>
#include <linux/errno.h>
#include <linux/proc_fs.h>
@@ -12,205 +11,351 @@
#include <linux/sched.h>
#include <linux/kthread.h>
#include <linux/device.h>
-MODULE_AUTHOR("\x5a\x54\x45");MODULE_LICENSE(
-"\x50\x72\x6f\x70\x72\x69\x65\x74\x61\x72\x79");extern unsigned int
-zOss_ResetNVFactory(void);extern unsigned int zOss_NvramFlush(void);extern
-unsigned int zOss_NvItemWrite(unsigned int,unsigned char*,unsigned int);extern
-int zDrvNand_Program(unsigned int,unsigned int,unsigned char*);extern void
-zOss_NvItemWriteFactory(unsigned int,unsigned char*,unsigned int);extern int
-zDrvNand_ChangeNvrAttr(unsigned int);extern unsigned int zOss_NvItemRead(
-unsigned int,unsigned char*,unsigned int);extern ssize_t zCatAgt_App_Write(const
- char*,size_t);extern ssize_t zCatAgt_Kernel_Write(const char*,size_t);extern
-void linux_oss_tick_timer_function(void);extern unsigned int
-zOss_GetExceptResetFlag(void);extern int zSys_ExceptReboot(unsigned int);extern
-int zDrvRpMsg_Write(const void*);extern int zDrvRpMsg_CreateChannel(unsigned int
-,unsigned int,unsigned int size);extern int zDrvRpMsg_RegCallBack(unsigned int,
-unsigned int,void*);extern int zAti_CidIsUsed(unsigned char);extern int
-zAti2_Send(unsigned char,unsigned char*,unsigned short,unsigned int);extern
-unsigned char zAti_GetDualCardStat(unsigned char*pbSim1Stat,unsigned char*
-pbSim2Stat,unsigned char*pbIsCardSwitching);extern unsigned char*zPutSkb2Psbuf(
-unsigned char*,unsigned short,unsigned char*,unsigned char*);extern unsigned
-short zGetUpLinkSduSize(void);extern int zAti2_Open(unsigned char);extern
-unsigned int zAt_AutoTestInit(void);extern int zAti2_IsExCid(unsigned char,
-unsigned char*);extern void zUsat_RegisterSendMsgFun(void*);extern int
-zAti2_RegRecvCb(void*);extern void zUsat_SendAtCmd(unsigned int,const unsigned
-char*,unsigned short,unsigned int);extern void AmtAgent_ComposeAndProcess(
-unsigned char*,unsigned int);extern void RegSendDataToAmtAppFunction(void*);
-extern void zDrvLpm_IrqDisable(unsigned int);extern void zDrvLpm_IrqEnable(
-unsigned int);extern void zDrvInt_MaskIrq(unsigned int);extern void
-zDrvInt_UnmaskIrq(unsigned int);extern int zPs_IsTdMasterMode(void);extern int
-zPs_IsLteMasterMode(void);extern int zPs_IsFddMasterMode(void);extern void
-psm_ModemDevSleep(void);extern bool psm_ModemSleepCheck(void);extern unsigned
-int psm_ModemSleepTimeGet(void);extern void psm_GetModemSleepFlagStatus(void);
-extern void psm_TimeCompensate(unsigned int);extern void zFreeDlBuf(unsigned
-char*);extern int zte_modem_start(void);extern unsigned long
-Comm_Read_CP_TO_AP_Data(const char*,unsigned long);extern unsigned long
-Comm_Write_AP_TO_CP_Data(const char*,unsigned long);extern int zDrvVoice_Close(
-void);extern int zDrvVoice_ReadStart(void);extern int zDrvVoice_ReadStop(void);
-extern int zDrvVoice_WriteStart(void);extern int zDrvVoice_WriteStop(void);
-extern int zDrvVoice_Open(void*);extern int zDrvVoice_WriteOneFrame(unsigned
-char*);extern int zDrvVoice_ReadOneFrame(unsigned char*);extern int
-halVoice_SetPathIn(void*);extern int halVoice_SetPathOut(void*);extern int
-halVoice_SetVolOut(void*);extern int halVoice_Enable(void);extern int
-halVoice_Open(void);extern int halVoice_Disable(void);extern int halVoice_Close(
-void);extern int halVoice_Open3G(void);extern int halVoice_Close3G(void);extern
-int zDrv_Audio_Printf(void*,...);extern void zDrvVp_SetDtmfMute_Wrap(void);
-extern int zDrvVp_SetTone_Wrap(int);extern int zDrvVp_SetMute_Wrap(int);extern
-int zDrvVp_GetMute_Wrap(void);extern int zDrvVp_SetRxMute_Wrap(int);extern int
-zDrvVp_GetRxMute_Wrap(void);extern int zDrvVp_SetVol_Wrap(int);extern int
-zDrvVp_GetVol_Wrap(void);extern int zDrvVp_GetTxVol_Wrap(void);extern int
-zDrvVp_SetTxVol_Wrap(int);extern int zDrvVp_SetVol_Gain_Wrap(int);extern int
-zDrvVp_GetVol_Gain_Wrap(void);extern int zDrvVp_SetTxVol_Gain_Wrap(int);extern
-int zDrvVp_GetTxVol_Gain_Wrap(void);extern int zDrvVp_GetPath_Wrap(void);extern
-int zDrvVp_Loop(int);extern int zDrvVp_Soft_Dtmf_Loop(int);extern void
-zDrvDtmf_Detect_RegCallbacks(T_DrvDtmf_Detect_Opt);extern int
-zDrvVp_SetPath_Wrap(int);extern int zDrvVp_GetPath_Wrap(void);extern int
-zDrvVp_GetSlicFlag(void);extern int zDrvVp_SetEchoDelay_Wrap(int val);extern int
- zDrvVp_GetEchoDelay_Wrap(void);extern int zDrvVp_SetTxNsMode_Wrap(int val);
-extern int zDrvVp_GetTxNsMode_Wrap(void);extern int zDrvVp_SetRxNsMode_Wrap(int
-val);extern int zDrvVp_GetRxNsMode_Wrap(void);extern int
-zDrvVp_SetModuleState_Wrap(int*,int);extern int zDrvVp_GetModuleState_Wrap(int*,
-int);extern VOID*mmp_AmrDecOpen(T_zMmp_CodecType codecType);extern VOID*
-mmp_AmrEncOpen(T_zMmp_CodecType codecType,BOOL isDtxEnable);extern UINT16
-mmp_AmrDecode(VOID*pCodecContext,const UINT8*pAmr,UINT16*pPcm);extern UINT16
-mmp_AmrEncode(VOID*pCodecContext,T_zMmp_AmrEncMode mode,const UINT16*pPcm,UINT8*
-pAmr);extern VOID mmp_AmrDecClose(VOID*pCodecContext);extern VOID
-mmp_AmrEncClose(VOID*pCodecContext);extern UINT8 zDrvEdcp_IsBusy(int EdcpNum);
-extern SINT32 zDrvVp_AudioDataWrite(const VOID*pBuf,UINT32 uiLen);extern SINT32
-zDrvVp_AudioDataOpen(UINT32 audioType,UINT32 sampleRate);extern SINT32
-zDrvVp_AudioDataClose(void);extern SINT32 zDrvVp_GetVpLoop_Wrap(VOID);extern
-VOID zDrvVp_Status(UINT32*sample_rate,UINT32*voice_status);extern VOID
-zDrvVp_UpdateVoiceNv(UINT8*voice_nv_update);extern int zDrvVp_SetVoiceProc_Wrap(
-int val);extern int zDrvVp_GetVoiceProc_Wrap(void);extern int
-zDrvVp_SetVoiceBuffer_Wrap(int en,int type);extern void
-zDrvVp_GetVoiceBuffer_Wrap(int*en,int*type);typedef struct cpko_section{unsigned
- int cpko_text_start;unsigned int cpko_rodata_start;unsigned int
-__utran_modem_text_start;unsigned int __lte_modem_text_start;unsigned int
-__comm_modem_text_start;unsigned int modem_text_end;unsigned int cpko_data_start
-;unsigned int cpko_bss_start;unsigned int cpko_text_offset;}cpko_section_layout;
-cpko_section_layout cpko_ps_section;int raise(int signo){return
-(0xbe2+1493-0x11b7);}extern unsigned int SysEntry(void);static int
-ko_Main_Thread(void*data){struct sched_param param={.sched_priority=
-MAX_USER_RT_PRIO/(0x4f+8692-0x2241)-(0xc10+5749-0x2282)};int ret=
-(0x6ec+936-0xa94);sched_setscheduler(current,SCHED_FIFO,¶m);ret=SysEntry();
-if(ret!=(0x1116+3896-0x204e))panic("Main_Thread\n");param.sched_priority=
-MAX_USER_RT_PRIO-(0xd7f+3763-0x1c04);sched_setscheduler(kthreadd_task,SCHED_FIFO
-,¶m);return(0x50b+1822-0xc29);}int zte_modem_ko_start(void){kthread_run(
-ko_Main_Thread,NULL,"\x5a\x54\x45\x4d\x61\x69\x6e\x54\x68\x72\x65\x61\x64");
-return(0xe73+5178-0x22ad);}static void cpko_sectioninfo_set(void){int ret;struct
- file*fp;mm_segment_t old_fs;loff_t cpko_pos=(0x157a+1546-0x1b84);struct
-cpps_globalModem globalVar;fp=filp_open(
-"\x2f\x6c\x69\x62\x2f\x63\x70\x6b\x6f\x2f\x63\x70\x6b\x6f\x5f\x73\x65\x63\x69\x6e\x66\x6f\x2e\x62\x69\x6e"
-,(0xb9+3122-0xceb),(0xd77+2874-0x18b1));if(IS_ERR(fp)||fp==NULL)panic(
-"\x6f\x70\x65\x6e\x20\x66\x69\x6c\x65\x20\x65\x72\x72\x6f\x72" "\n");old_fs=
-get_fs();set_fs(KERNEL_DS);ret=vfs_read(fp,(char*)&cpko_ps_section,sizeof(
-cpko_section_layout),&cpko_pos);if(ret<=(0xa3c+5561-0x1ff5))panic(
-"\x72\x65\x61\x64\x20\x66\x69\x6c\x65\x20\x65\x72\x72\x6f\x72" "\n");filp_close(
-fp,NULL);
+
+MODULE_AUTHOR("ZTE");
+MODULE_LICENSE("Proprietary");
+
+extern unsigned int zOss_ResetNVFactory(void);
+extern unsigned int zOss_NvramFlush(void);
+extern unsigned int zOss_NvItemWrite(unsigned int,unsigned char *,unsigned int);
+extern int zDrvNand_Program(unsigned int,unsigned int,unsigned char *);
+extern void zOss_NvItemWriteFactory(unsigned int,unsigned char *,unsigned int);
+extern int zDrvNand_ChangeNvrAttr(unsigned int);
+extern unsigned int zOss_NvItemRead(unsigned int,unsigned char *,unsigned int);
+extern ssize_t zCatAgt_App_Write(const char *, size_t);
+extern ssize_t zCatAgt_Kernel_Write(const char *, size_t);
+extern void linux_oss_tick_timer_function(void);
+extern unsigned int zOss_GetExceptResetFlag(void);
+extern int zSys_ExceptReboot(unsigned int);
+extern int zDrvRpMsg_Write(const void *);
+extern int zDrvRpMsg_CreateChannel(unsigned int, unsigned int, unsigned int size);
+extern int zDrvRpMsg_RegCallBack(unsigned int, unsigned int, void *);
+extern int zAti_CidIsUsed(unsigned char);
+//extern unsigned char *zGetpsbufferHead(unsigned char *);
+extern int zAti2_Send(unsigned char , unsigned char *, unsigned short , unsigned int );
+extern unsigned char zAti_GetDualCardStat(unsigned char *pbSim1Stat, unsigned char *pbSim2Stat, unsigned char *pbIsCardSwitching);
+extern unsigned char *zPutSkb2Psbuf(unsigned char *, unsigned short, unsigned char *, unsigned char *);
+extern unsigned short zGetUpLinkSduSize(void);
+extern int zAti2_Open(unsigned char);
+extern unsigned int zAt_AutoTestInit(void);
+extern int zAti2_IsExCid(unsigned char,unsigned char *);
+extern void zUsat_RegisterSendMsgFun(void *);
+extern int zAti2_RegRecvCb(void *);
+extern void zUsat_SendAtCmd(unsigned int, const unsigned char *, unsigned short, unsigned int);
+extern void AmtAgent_ComposeAndProcess(unsigned char *, unsigned int);
+extern void RegSendDataToAmtAppFunction(void *);
+extern void zDrvLpm_IrqDisable(unsigned int);
+extern void zDrvLpm_IrqEnable(unsigned int);
+extern void zDrvInt_MaskIrq(unsigned int);
+extern void zDrvInt_UnmaskIrq(unsigned int);
+extern int zPs_IsTdMasterMode(void);
+extern int zPs_IsLteMasterMode(void);
+extern int zPs_IsFddMasterMode(void);
+extern void psm_ModemDevSleep(void);
+extern bool psm_ModemSleepCheck(void);
+extern unsigned int psm_ModemSleepTimeGet(void);
+extern void psm_GetModemSleepFlagStatus(void);
+extern void psm_TimeCompensate(unsigned int);
+extern void zFreeDlBuf(unsigned char *);
+extern int zte_modem_start(void);
+extern unsigned long Comm_Read_CP_TO_AP_Data(const char *, unsigned long);
+extern unsigned long Comm_Write_AP_TO_CP_Data(const char *, unsigned long);
+extern int zDrvVoice_Close(void);
+extern int zDrvVoice_ReadStart(void);
+extern int zDrvVoice_ReadStop(void);
+extern int zDrvVoice_WriteStart(void);
+extern int zDrvVoice_WriteStop(void);
+extern int zDrvVoice_Open(void *);
+extern int zDrvVoice_WriteOneFrame(unsigned char *);
+extern int zDrvVoice_ReadOneFrame(unsigned char *);
+extern int halVoice_SetPathIn(void *);
+extern int halVoice_SetPathOut(void *);
+extern int halVoice_SetVolOut(void *);
+extern int halVoice_Enable(void);
+extern int halVoice_Open(void);
+extern int halVoice_Disable(void);
+extern int halVoice_Close(void);
+extern int halVoice_Open3G(void);
+extern int halVoice_Close3G(void);
+extern int zDrv_Audio_Printf(void *, ...);
+extern void zDrvVp_SetDtmfMute_Wrap(void);
+extern int zDrvVp_SetTone_Wrap(int);
+extern int zDrvVp_SetMute_Wrap(int);
+extern int zDrvVp_GetMute_Wrap(void);
+extern int zDrvVp_SetRxMute_Wrap(int );
+extern int zDrvVp_GetRxMute_Wrap(void);
+extern int zDrvVp_SetVol_Wrap(int);
+extern int zDrvVp_GetVol_Wrap(void);
+extern int zDrvVp_GetTxVol_Wrap(void);
+extern int zDrvVp_SetTxVol_Wrap(int);
+extern int zDrvVp_SetVol_Gain_Wrap(int);
+extern int zDrvVp_GetVol_Gain_Wrap(void);
+extern int zDrvVp_SetTxVol_Gain_Wrap(int);
+extern int zDrvVp_GetTxVol_Gain_Wrap(void);
+extern int zDrvVp_GetPath_Wrap(void);
+extern int zDrvVp_Loop(int);
+extern int zDrvVp_Soft_Dtmf_Loop(int);
+extern void zDrvDtmf_Detect_RegCallbacks(T_DrvDtmf_Detect_Opt);
+extern int zDrvVp_SetPath_Wrap(int);
+extern int zDrvVp_GetPath_Wrap(void);
+extern int zDrvVp_GetSlicFlag(void);
+extern int zDrvVp_SetEchoDelay_Wrap(int val);
+extern int zDrvVp_GetEchoDelay_Wrap(void);
+extern int zDrvVp_SetTxNsMode_Wrap(int val);
+extern int zDrvVp_GetTxNsMode_Wrap(void);
+extern int zDrvVp_SetRxNsMode_Wrap(int val);
+extern int zDrvVp_GetRxNsMode_Wrap(void);
+extern int zDrvVp_SetModuleState_Wrap(int *,int);
+extern int zDrvVp_GetModuleState_Wrap(int *,int);
+extern VOID* mmp_AmrDecOpen (T_zMmp_CodecType codecType);
+extern VOID* mmp_AmrEncOpen (T_zMmp_CodecType codecType, BOOL isDtxEnable);
+extern UINT16 mmp_AmrDecode (VOID *pCodecContext, const UINT8 *pAmr, UINT16 *pPcm);
+extern UINT16 mmp_AmrEncode (VOID *pCodecContext, T_zMmp_AmrEncMode mode, const UINT16 *pPcm, UINT8 *pAmr);
+extern VOID mmp_AmrDecClose (VOID *pCodecContext);
+extern VOID mmp_AmrEncClose (VOID *pCodecContext);
+extern UINT8 zDrvEdcp_IsBusy(int EdcpNum);
+extern SINT32 zDrvVp_AudioDataWrite(const VOID *pBuf, UINT32 uiLen);
+extern SINT32 zDrvVp_AudioDataOpen(UINT32 audioType, UINT32 sampleRate);
+extern SINT32 zDrvVp_AudioDataClose(void);
+extern SINT32 zDrvVp_GetVpLoop_Wrap(VOID);
+extern VOID zDrvVp_Status(UINT32 *sample_rate, UINT32 *voice_status);
+extern VOID zDrvVp_UpdateVoiceNv(UINT8 *voice_nv_update);
+extern int zDrvVp_SetVoiceProc_Wrap(int val);
+extern int zDrvVp_GetVoiceProc_Wrap(void);
+extern int zDrvVp_SetVoiceBuffer_Wrap(int en,int type);
+extern void zDrvVp_GetVoiceBuffer_Wrap(int *en,int *type);
+
+
+
+
+typedef struct cpko_section {
+ unsigned int cpko_text_start;
+ unsigned int cpko_rodata_start;
+ unsigned int __utran_modem_text_start;
+ unsigned int __lte_modem_text_start;
+ unsigned int __comm_modem_text_start;
+ unsigned int modem_text_end;
+ unsigned int cpko_data_start;
+ unsigned int cpko_bss_start;
+ unsigned int cpko_text_offset;
+} cpko_section_layout;
+cpko_section_layout cpko_ps_section;
+
+
+int raise(int signo)
+{
+ return 0x00;
+}
+
+//__initdata DECLARE_COMPLETION(sysentry_done);
+
+extern unsigned int SysEntry(void);
+static int ko_Main_Thread(void * data)
+{
+ struct sched_param param = { .sched_priority = MAX_USER_RT_PRIO/2 - 3 };
+ int ret = 0;
+
+ sched_setscheduler(current, SCHED_FIFO, ¶m);
+
+ ret = SysEntry();
+ if(ret != 0)
+ panic("Main_Thread\n");
+
+ param.sched_priority = MAX_USER_RT_PRIO - 46;
+ sched_setscheduler(kthreadd_task, SCHED_FIFO, ¶m);
+
+ return 0;
+}
+
+int zte_modem_ko_start(void)
+{
+
+ kthread_run(ko_Main_Thread, NULL, "ZTEMainThread");
+ //wait_for_completion(&sysentry_done);
+
+ return 0;
+}
+static void cpko_sectioninfo_set(void)
+{
+ int ret;
+ struct file *fp;
+ mm_segment_t old_fs;
+ loff_t cpko_pos = 0;
+ struct cpps_globalModem globalVar;
+
+ fp = filp_open("/lib/cpko/cpko_secinfo.bin", 0, 0);
+ if(IS_ERR(fp) || fp == NULL)
+ panic("open file error\n");
+
+ old_fs = get_fs();
+ set_fs(KERNEL_DS);
+ ret = vfs_read(fp, (char*)&cpko_ps_section, sizeof(cpko_section_layout), &cpko_pos);
+ if (ret <= 0)
+ panic("read file error\n");
+ filp_close(fp, NULL);
+
#ifdef CONFIG_MODEM_CODE_IS_MAPPING
-fp=filp_open(
-"\x2f\x6c\x69\x62\x2f\x63\x70\x6b\x6f\x2f\x63\x70\x6b\x6f\x2e\x6b\x6f",
-(0x12d8+3575-0x20cf),(0x11ad+2890-0x1cf7));if(IS_ERR(fp)||fp==NULL)panic(
-"\x6f\x70\x65\x6e\x20\x66\x69\x6c\x65\x20\x65\x72\x72\x6f\x72" "\n");fp->f_ra.
-ra_pages=(0xec5+3427-0x1c28);
+ fp = filp_open("/lib/cpko/cpko.ko",0, 0);
+ if(IS_ERR(fp) || fp == NULL)
+ panic("open file error\n");
+ fp->f_ra.ra_pages = 0;
#endif
-if(cpko_ps_section.cpko_text_start){globalVar.cpko_text_start=(unsigned long)
-cpko_ps_section.cpko_text_start;globalVar.cpko_rodata_start=(unsigned long)
-cpko_ps_section.cpko_rodata_start;globalVar.cpko_data_start=(unsigned long)
-cpko_ps_section.cpko_data_start;globalVar.cpko_bss_start=(unsigned long)
-cpko_ps_section.cpko_bss_start;
+
+ if (cpko_ps_section.cpko_text_start){
+ globalVar.cpko_text_start = (unsigned long)cpko_ps_section.cpko_text_start;
+ globalVar.cpko_rodata_start = (unsigned long)cpko_ps_section.cpko_rodata_start;
+ globalVar.cpko_data_start = (unsigned long)cpko_ps_section.cpko_data_start;
+ globalVar.cpko_bss_start = (unsigned long)cpko_ps_section.cpko_bss_start;
+
+
#ifdef CONFIG_MODEM_CODE_IS_MAPPING
-globalVar.fp_code=fp;globalVar.__utran_modem_text_start=(unsigned long)
-cpko_ps_section.__utran_modem_text_start;globalVar.__lte_modem_text_start=(
-unsigned long)cpko_ps_section.__lte_modem_text_start;globalVar.
-__comm_modem_text_start=(unsigned long)cpko_ps_section.__comm_modem_text_start;
-globalVar.modem_text_end=(unsigned long)cpko_ps_section.modem_text_end;globalVar
-.modem_offset=cpko_ps_section.cpko_text_offset;
+ globalVar.fp_code = fp;
+ globalVar.__utran_modem_text_start = (unsigned long)cpko_ps_section.__utran_modem_text_start;
+ globalVar.__lte_modem_text_start = (unsigned long)cpko_ps_section.__lte_modem_text_start;
+ globalVar.__comm_modem_text_start = (unsigned long)cpko_ps_section.__comm_modem_text_start;
+ globalVar.modem_text_end = (unsigned long)cpko_ps_section.modem_text_end;
+ globalVar.modem_offset = cpko_ps_section.cpko_text_offset;
#endif
-cpps_globalVar_register(&globalVar);
+ cpps_globalVar_register(&globalVar);
+
#ifdef CONFIG_MODEM_CODE_IS_MAPPING
-vfree_modem_section(globalVar.cpko_text_start,globalVar.modem_text_end);
+ vfree_modem_section(globalVar.cpko_text_start, globalVar.modem_text_end);
#endif
-}else panic("\x66\x69\x6c\x65\x20\x65\x72\x72\x6f\x72" "\n");}static int
-cpko_start(void){struct cpps_callbacks callback={(0x4ea+531-0x6fd)};callback.
-zOss_ResetNVFactory=zOss_ResetNVFactory;callback.zOss_NvramFlush=zOss_NvramFlush
-;callback.zOss_NvItemWrite=zOss_NvItemWrite;callback.zOss_NvItemWriteFactory=
-zOss_NvItemWriteFactory;callback.zOss_NvItemRead=zOss_NvItemRead;callback.
-zCatAgt_App_Write=zCatAgt_App_Write;callback.zCatAgt_Kernel_Write=
-zCatAgt_Kernel_Write;callback.linux_oss_tick_timer_function=
-linux_oss_tick_timer_function;callback.zOss_GetExceptResetFlag=
-zOss_GetExceptResetFlag;callback.zSys_ExceptReboot=zSys_ExceptReboot;callback.
-zDrvRpMsg_Write=zDrvRpMsg_Write;callback.zDrvRpMsg_CreateChannel=
-zDrvRpMsg_CreateChannel;callback.zDrvRpMsg_RegCallBack=zDrvRpMsg_RegCallBack;
-callback.zDrvLpm_IrqDisable=zDrvLpm_IrqDisable;callback.zDrvInt_MaskIrq=
-zDrvInt_MaskIrq;callback.zDrvLpm_IrqEnable=zDrvLpm_IrqEnable;callback.
-zDrvInt_UnmaskIrq=zDrvInt_UnmaskIrq;callback.Comm_Read_CP_TO_AP_Data=
-Comm_Read_CP_TO_AP_Data;callback.Comm_Write_AP_TO_CP_Data=
-Comm_Write_AP_TO_CP_Data;callback.zDrvEdcp_IsBusy=zDrvEdcp_IsBusy;
+ }
+ else
+ panic("file error\n");
+}
+static int cpko_start(void)
+{
+ struct cpps_callbacks callback = {0};
+
+ //memset(&callback, 0 , sizeof(callback));
+
+ callback.zOss_ResetNVFactory = zOss_ResetNVFactory;
+ callback.zOss_NvramFlush = zOss_NvramFlush;
+ callback.zOss_NvItemWrite = zOss_NvItemWrite;
+ callback.zOss_NvItemWriteFactory = zOss_NvItemWriteFactory;
+ callback.zOss_NvItemRead = zOss_NvItemRead;
+ callback.zCatAgt_App_Write = zCatAgt_App_Write;
+ callback.zCatAgt_Kernel_Write = zCatAgt_Kernel_Write;
+ callback.linux_oss_tick_timer_function = linux_oss_tick_timer_function;
+ callback.zOss_GetExceptResetFlag = zOss_GetExceptResetFlag;
+ callback.zSys_ExceptReboot = zSys_ExceptReboot;
+ callback.zDrvRpMsg_Write = zDrvRpMsg_Write;
+ callback.zDrvRpMsg_CreateChannel = zDrvRpMsg_CreateChannel;
+ callback.zDrvRpMsg_RegCallBack = zDrvRpMsg_RegCallBack;
+ callback.zDrvLpm_IrqDisable = zDrvLpm_IrqDisable;
+ callback.zDrvInt_MaskIrq = zDrvInt_MaskIrq;
+ callback.zDrvLpm_IrqEnable = zDrvLpm_IrqEnable;
+ callback.zDrvInt_UnmaskIrq = zDrvInt_UnmaskIrq;
+ callback.Comm_Read_CP_TO_AP_Data = Comm_Read_CP_TO_AP_Data;
+ callback.Comm_Write_AP_TO_CP_Data = Comm_Write_AP_TO_CP_Data;
+ callback.zDrvEdcp_IsBusy = zDrvEdcp_IsBusy;
+
#ifndef _USE_TestHarness
-callback.zAti2_Open=zAti2_Open;callback.zAt_AutoTestInit=zAt_AutoTestInit;
-callback.zAti2_IsExCid=zAti2_IsExCid;callback.zPutSkb2Psbuf=zPutSkb2Psbuf;
-callback.zAti_CidIsUsed=zAti_CidIsUsed;callback.zAti2_Send=zAti2_Send;callback.
-zAti_GetDualCardStat=zAti_GetDualCardStat;callback.zGetUpLinkSduSize=
-zGetUpLinkSduSize;callback.zUsat_RegisterSendMsgFun=zUsat_RegisterSendMsgFun;
-callback.zAti2_RegRecvCb=zAti2_RegRecvCb;callback.zUsat_SendAtCmd=
-zUsat_SendAtCmd;callback.RegSendDataToAmtAppFunction=RegSendDataToAmtAppFunction
-;callback.zFreeDlBuf=zFreeDlBuf;callback.AmtAgent_ComposeAndProcess=
-AmtAgent_ComposeAndProcess;callback.zPs_IsTdMasterMode=zPs_IsTdMasterMode;
-callback.zPs_IsLteMasterMode=zPs_IsLteMasterMode;callback.zPs_IsFddMasterMode=
-zPs_IsFddMasterMode;
+ callback.zAti2_Open = zAti2_Open;
+ callback.zAt_AutoTestInit = zAt_AutoTestInit;
+ callback.zAti2_IsExCid = zAti2_IsExCid;
+ callback.zPutSkb2Psbuf = zPutSkb2Psbuf;
+ //callback.zGetpsbufferHead = zGetpsbufferHead;
+ callback.zAti_CidIsUsed = zAti_CidIsUsed;
+ callback.zAti2_Send = zAti2_Send;
+ callback.zAti_GetDualCardStat = zAti_GetDualCardStat;
+ callback.zGetUpLinkSduSize = zGetUpLinkSduSize;
+ callback.zUsat_RegisterSendMsgFun = zUsat_RegisterSendMsgFun;
+ callback.zAti2_RegRecvCb = zAti2_RegRecvCb;
+ callback.zUsat_SendAtCmd = zUsat_SendAtCmd;
+ callback.RegSendDataToAmtAppFunction = RegSendDataToAmtAppFunction;
+ callback.zFreeDlBuf = zFreeDlBuf;
+ callback.AmtAgent_ComposeAndProcess = AmtAgent_ComposeAndProcess;
+ callback.zPs_IsTdMasterMode = zPs_IsTdMasterMode;
+ callback.zPs_IsLteMasterMode = zPs_IsLteMasterMode;
+ callback.zPs_IsFddMasterMode = zPs_IsFddMasterMode;
#ifdef USE_VOICE_SUPPORT
-callback.zDrvVoice_Close=zDrvVoice_Close;callback.zDrvVoice_ReadStart=
-zDrvVoice_ReadStart;callback.zDrvVoice_ReadStop=zDrvVoice_ReadStop;callback.
-zDrvVoice_WriteStart=zDrvVoice_WriteStart;callback.zDrvVoice_WriteStop=
-zDrvVoice_WriteStop;callback.zDrvVoice_Open=zDrvVoice_Open;callback.
-zDrvVoice_WriteOneFrame=zDrvVoice_WriteOneFrame;callback.zDrvVoice_ReadOneFrame=
-zDrvVoice_ReadOneFrame;callback.halVoice_SetPathIn=halVoice_SetPathIn;callback.
-halVoice_SetPathOut=halVoice_SetPathOut;callback.halVoice_SetVolOut=
-halVoice_SetVolOut;callback.halVoice_Enable=halVoice_Enable;callback.
-halVoice_Open=halVoice_Open;callback.halVoice_Disable=halVoice_Disable;callback.
-halVoice_Close=halVoice_Close;callback.zDrv_Audio_Printf=zDrv_Audio_Printf;
-callback.zDrvVp_SetTone_Wrap=zDrvVp_SetTone_Wrap;callback.zDrvVp_SetMute_Wrap=
-zDrvVp_SetMute_Wrap;callback.zDrvVp_GetMute_Wrap=zDrvVp_GetMute_Wrap;callback.
-zDrvVp_SetRxMute_Wrap=zDrvVp_SetRxMute_Wrap;callback.zDrvVp_GetRxMute_Wrap=
-zDrvVp_GetRxMute_Wrap;callback.zDrvVp_SetVol_Wrap=zDrvVp_SetVol_Wrap;callback.
-zDrvVp_GetVol_Wrap=zDrvVp_GetVol_Wrap;callback.zDrvVp_SetDtmfMute_Wrap=
-zDrvVp_SetDtmfMute_Wrap;callback.zDrvVp_SetTxVol_Wrap=zDrvVp_SetTxVol_Wrap;
-callback.zDrvVp_GetTxVol_Wrap=zDrvVp_GetTxVol_Wrap;callback.
-zDrvVp_SetVol_Gain_Wrap=zDrvVp_SetVol_Gain_Wrap;callback.zDrvVp_GetVol_Gain_Wrap
-=zDrvVp_GetVol_Gain_Wrap;callback.zDrvVp_SetTxVol_Gain_Wrap=
-zDrvVp_SetTxVol_Gain_Wrap;callback.zDrvVp_GetTxVol_Gain_Wrap=
-zDrvVp_GetTxVol_Gain_Wrap;callback.zDrvVp_GetPath_Wrap=zDrvVp_GetPath_Wrap;
-callback.zDrvVp_Loop=zDrvVp_Loop;callback.zDrvVp_GetVpLoop_Wrap=
-zDrvVp_GetVpLoop_Wrap;callback.zDrvVp_Soft_Dtmf_Loop=zDrvVp_Soft_Dtmf_Loop;
-callback.zDrvDtmf_Detect_RegCallbacks=zDrvDtmf_Detect_RegCallbacks;callback.
-zDrvVp_SetPath_Wrap=zDrvVp_SetPath_Wrap;callback.zDrvVp_GetPath_Wrap=
-zDrvVp_GetPath_Wrap;callback.halVoice_Open3G=halVoice_Open3G;callback.
-halVoice_Close3G=halVoice_Close3G;callback.zDrvVp_GetSlicFlag=zDrvVp_GetSlicFlag
-;callback.zDrvVp_SetVoiceProc_Wrap=zDrvVp_SetVoiceProc_Wrap;callback.
-zDrvVp_GetVoiceProc_Wrap=zDrvVp_GetVoiceProc_Wrap;callback.
-zDrvVp_SetVoiceBuffer_Wrap=zDrvVp_SetVoiceBuffer_Wrap;callback.
-zDrvVp_GetVoiceBuffer_Wrap=zDrvVp_GetVoiceBuffer_Wrap;callback.
-zDrvVp_SetEchoDelay_Wrap=zDrvVp_SetEchoDelay_Wrap;callback.
-zDrvVp_GetEchoDelay_Wrap=zDrvVp_GetEchoDelay_Wrap;callback.
-zDrvVp_SetTxNsMode_Wrap=zDrvVp_SetTxNsMode_Wrap;callback.zDrvVp_GetTxNsMode_Wrap
-=zDrvVp_GetTxNsMode_Wrap;callback.zDrvVp_SetRxNsMode_Wrap=
-zDrvVp_SetRxNsMode_Wrap;callback.zDrvVp_GetRxNsMode_Wrap=zDrvVp_GetRxNsMode_Wrap
-;callback.zDrvVp_SetModuleState_Wrap=zDrvVp_SetModuleState_Wrap;callback.
-zDrvVp_GetModuleState_Wrap=zDrvVp_GetModuleState_Wrap;callback.mmp_AmrDecOpen=
-mmp_AmrDecOpen;callback.mmp_AmrEncOpen=mmp_AmrEncOpen;callback.mmp_AmrDecode=
-mmp_AmrDecode;callback.mmp_AmrEncode=mmp_AmrEncode;callback.mmp_AmrDecClose=
-mmp_AmrDecClose;callback.mmp_AmrEncClose=mmp_AmrEncClose;callback.
-zDrvVp_AudioDataOpen=zDrvVp_AudioDataOpen;callback.zDrvVp_AudioDataWrite=
-zDrvVp_AudioDataWrite;callback.zDrvVp_AudioDataClose=zDrvVp_AudioDataClose;
-callback.zDrvVp_Status=zDrvVp_Status;callback.zDrvVp_UpdateVoiceNv=
-zDrvVp_UpdateVoiceNv;
+ callback.zDrvVoice_Close = zDrvVoice_Close;
+ callback.zDrvVoice_ReadStart = zDrvVoice_ReadStart;
+ callback.zDrvVoice_ReadStop = zDrvVoice_ReadStop;
+ callback.zDrvVoice_WriteStart = zDrvVoice_WriteStart;
+ callback.zDrvVoice_WriteStop = zDrvVoice_WriteStop;
+ callback.zDrvVoice_Open = zDrvVoice_Open;
+ callback.zDrvVoice_WriteOneFrame = zDrvVoice_WriteOneFrame;
+ callback.zDrvVoice_ReadOneFrame = zDrvVoice_ReadOneFrame;
+ callback.halVoice_SetPathIn = halVoice_SetPathIn;
+ callback.halVoice_SetPathOut = halVoice_SetPathOut;
+ callback.halVoice_SetVolOut = halVoice_SetVolOut;
+ callback.halVoice_Enable = halVoice_Enable;
+ callback.halVoice_Open = halVoice_Open;
+ callback.halVoice_Disable = halVoice_Disable;
+ callback.halVoice_Close = halVoice_Close;
+ callback.zDrv_Audio_Printf = zDrv_Audio_Printf;
+ callback.zDrvVp_SetTone_Wrap = zDrvVp_SetTone_Wrap;
+ callback.zDrvVp_SetMute_Wrap = zDrvVp_SetMute_Wrap;
+ callback.zDrvVp_GetMute_Wrap = zDrvVp_GetMute_Wrap;
+ callback.zDrvVp_SetRxMute_Wrap = zDrvVp_SetRxMute_Wrap;
+ callback.zDrvVp_GetRxMute_Wrap = zDrvVp_GetRxMute_Wrap;
+ callback.zDrvVp_SetVol_Wrap = zDrvVp_SetVol_Wrap;
+ callback.zDrvVp_GetVol_Wrap = zDrvVp_GetVol_Wrap;
+ callback.zDrvVp_SetDtmfMute_Wrap = zDrvVp_SetDtmfMute_Wrap;
+ callback.zDrvVp_SetTxVol_Wrap = zDrvVp_SetTxVol_Wrap;
+ callback.zDrvVp_GetTxVol_Wrap = zDrvVp_GetTxVol_Wrap;
+ callback.zDrvVp_SetVol_Gain_Wrap = zDrvVp_SetVol_Gain_Wrap;
+ callback.zDrvVp_GetVol_Gain_Wrap = zDrvVp_GetVol_Gain_Wrap;
+ callback.zDrvVp_SetTxVol_Gain_Wrap = zDrvVp_SetTxVol_Gain_Wrap;
+ callback.zDrvVp_GetTxVol_Gain_Wrap = zDrvVp_GetTxVol_Gain_Wrap;
+ callback.zDrvVp_GetPath_Wrap = zDrvVp_GetPath_Wrap;
+ callback.zDrvVp_Loop = zDrvVp_Loop;
+ callback.zDrvVp_GetVpLoop_Wrap = zDrvVp_GetVpLoop_Wrap;
+ callback.zDrvVp_Soft_Dtmf_Loop = zDrvVp_Soft_Dtmf_Loop;
+ callback.zDrvDtmf_Detect_RegCallbacks = zDrvDtmf_Detect_RegCallbacks;
+ callback.zDrvVp_SetPath_Wrap = zDrvVp_SetPath_Wrap;
+ callback.zDrvVp_GetPath_Wrap = zDrvVp_GetPath_Wrap;
+ callback.halVoice_Open3G = halVoice_Open3G;
+ callback.halVoice_Close3G = halVoice_Close3G;
+ callback.zDrvVp_GetSlicFlag = zDrvVp_GetSlicFlag;
+ callback.zDrvVp_SetVoiceProc_Wrap = zDrvVp_SetVoiceProc_Wrap;
+ callback.zDrvVp_GetVoiceProc_Wrap = zDrvVp_GetVoiceProc_Wrap;
+ callback.zDrvVp_SetVoiceBuffer_Wrap = zDrvVp_SetVoiceBuffer_Wrap;
+ callback.zDrvVp_GetVoiceBuffer_Wrap = zDrvVp_GetVoiceBuffer_Wrap;
+ callback.zDrvVp_SetEchoDelay_Wrap = zDrvVp_SetEchoDelay_Wrap;
+ callback.zDrvVp_GetEchoDelay_Wrap = zDrvVp_GetEchoDelay_Wrap;
+ callback.zDrvVp_SetTxNsMode_Wrap = zDrvVp_SetTxNsMode_Wrap;
+ callback.zDrvVp_GetTxNsMode_Wrap = zDrvVp_GetTxNsMode_Wrap;
+ callback.zDrvVp_SetRxNsMode_Wrap = zDrvVp_SetRxNsMode_Wrap;
+ callback.zDrvVp_GetRxNsMode_Wrap = zDrvVp_GetRxNsMode_Wrap;
+ callback.zDrvVp_SetModuleState_Wrap = zDrvVp_SetModuleState_Wrap;
+ callback.zDrvVp_GetModuleState_Wrap = zDrvVp_GetModuleState_Wrap;
+ callback.mmp_AmrDecOpen = mmp_AmrDecOpen;
+ callback.mmp_AmrEncOpen = mmp_AmrEncOpen;
+ callback.mmp_AmrDecode = mmp_AmrDecode;
+ callback.mmp_AmrEncode = mmp_AmrEncode;
+ callback.mmp_AmrDecClose = mmp_AmrDecClose;
+ callback.mmp_AmrEncClose = mmp_AmrEncClose;
+ callback.zDrvVp_AudioDataOpen = zDrvVp_AudioDataOpen;
+ callback.zDrvVp_AudioDataWrite = zDrvVp_AudioDataWrite;
+ callback.zDrvVp_AudioDataClose = zDrvVp_AudioDataClose;
+ callback.zDrvVp_Status = zDrvVp_Status;
+ callback.zDrvVp_UpdateVoiceNv = zDrvVp_UpdateVoiceNv;
#endif
-callback.psm_ModemDevSleep=psm_ModemDevSleep;callback.psm_ModemSleepCheck=
-psm_ModemSleepCheck;callback.psm_ModemSleepTimeGet=psm_ModemSleepTimeGet;
-callback.psm_TimeCompensate=psm_TimeCompensate;callback.
-psm_GetModemSleepFlagStatus=psm_GetModemSleepFlagStatus;
+ callback.psm_ModemDevSleep = psm_ModemDevSleep;
+ callback.psm_ModemSleepCheck = psm_ModemSleepCheck;
+ callback.psm_ModemSleepTimeGet = psm_ModemSleepTimeGet;
+ callback.psm_TimeCompensate = psm_TimeCompensate;
+ callback.psm_GetModemSleepFlagStatus = psm_GetModemSleepFlagStatus;
+
#endif
-cpps_callbacks_register(&callback);cpko_sectioninfo_set();zte_modem_ko_start();
-return(0x78b+3070-0x1389);}static int cpko_stop(void){return(0xe11+1744-0x14e1);
-}module_init(cpko_start);module_exit(cpko_stop);
+
+
+ cpps_callbacks_register(&callback);
+ cpko_sectioninfo_set();
+ zte_modem_ko_start();
+
+ return 0;
+}
+
+static int cpko_stop(void)
+{
+ return 0;
+}
+
+module_init(cpko_start);
+module_exit(cpko_stop);
diff --git a/ap/os/linux/linux-3.4.x/drivers/mtd/mtdcore.c b/ap/os/linux/linux-3.4.x/drivers/mtd/mtdcore.c
index c837507..41e3903 100644
--- a/ap/os/linux/linux-3.4.x/drivers/mtd/mtdcore.c
+++ b/ap/os/linux/linux-3.4.x/drivers/mtd/mtdcore.c
@@ -40,6 +40,8 @@
#include <linux/mtd/mtd.h>
#include <linux/mtd/partitions.h>
+#include <linux/uaccess.h>
+
#include "mtdcore.h"
/*
* backing device capabilities for non-mappable devices (such as NAND flash)
@@ -250,6 +252,17 @@
}
static DEVICE_ATTR(name, S_IRUGO, mtd_name_show, NULL);
+#define MTD_RECORD_NAME_MAX (16)
+struct zxic_mtd_record
+{
+ char name[MTD_RECORD_NAME_MAX];
+ unsigned int erase_times;
+ unsigned int write_times;
+};
+
+static struct zxic_mtd_record g_zxic_mtd_record; //save data
+static int record_mtd_trigger_flag; // 0 stop record, 1 start record
+
static struct attribute *mtd_attrs[] = {
&dev_attr_type.attr,
&dev_attr_flags.attr,
@@ -701,6 +714,9 @@
mtd_erase_callback(instr);
return 0;
}
+
+ if (record_mtd_trigger_flag && (strcmp(mtd->name, g_zxic_mtd_record.name) == 0))
+ g_zxic_mtd_record.erase_times++;
return mtd->_erase(mtd, instr);
}
EXPORT_SYMBOL_GPL(mtd_erase);
@@ -776,6 +792,9 @@
return -EROFS;
if (!len)
return 0;
+ if (record_mtd_trigger_flag && (strcmp(mtd->name, g_zxic_mtd_record.name) == 0))
+ g_zxic_mtd_record.write_times++;
+
return mtd->_write(mtd, to, len, retlen, buf);
}
EXPORT_SYMBOL_GPL(mtd_write);
@@ -1092,6 +1111,119 @@
return ret;
}
+/* Started by AICoder, pid:5fc9ey6dc555c241432c0bd800e0358e8d683380 */
+static struct proc_dir_entry *proc_record_mtd_name;
+static struct proc_dir_entry *proc_record_mtd_trigger;
+static struct proc_dir_entry *proc_record_mtd_erase_times;
+
+static ssize_t proc_record_mtd_name_read(struct file *file, char __user *user_buffer, size_t count, loff_t *offset) {
+ if (g_zxic_mtd_record.name[0] != '\0')
+ return simple_read_from_buffer(user_buffer, count, offset, g_zxic_mtd_record.name, strlen(g_zxic_mtd_record.name));
+ else
+ return 0;
+}
+
+static ssize_t proc_record_mtd_name_write(struct file *file, const char __user *user_buffer, size_t count, loff_t *offset) {
+ if (count <= 1 || count >= MTD_RECORD_NAME_MAX) {
+ return -EINVAL;
+ }
+
+ if (copy_from_user(g_zxic_mtd_record.name, user_buffer, count)) {
+ return -EFAULT;
+ }
+
+ g_zxic_mtd_record.name[count-1] = '\0'; // last 1 byte 0x0a
+ g_zxic_mtd_record.erase_times = 0;
+ g_zxic_mtd_record.write_times = 0;
+
+ return count;
+}
+
+static ssize_t proc_record_mtd_trigger_read(struct file *file, char __user *user_buffer, size_t count, loff_t *offset) {
+ if (record_mtd_trigger_flag)
+ return simple_read_from_buffer(user_buffer, count, offset, "start\n", 6);
+ else
+ return simple_read_from_buffer(user_buffer, count, offset, "stop\n", 5);
+}
+
+static ssize_t proc_record_mtd_trigger_write(struct file *file, const char __user *user_buffer, size_t count, loff_t *offset) {
+ char buffer[10];
+
+ if (count < 4 || count > 6)
+ return -EINVAL;
+ if (g_zxic_mtd_record.name[0] == '\0')
+ return -EINVAL; // mtd name not set
+ if (copy_from_user(buffer, user_buffer, count))
+ return -EFAULT;
+
+ buffer[count-1] = '\0'; // last 1 byte 0x0a
+ //printk("record mtd trigger:%s\n", buffer);
+
+ if (memcmp(buffer, "start", 5) == 0) {
+ printk(KERN_WARNING "record mtd erase and write start\n");
+ g_zxic_mtd_record.erase_times = 0;
+ g_zxic_mtd_record.write_times = 0;
+ record_mtd_trigger_flag = 1;
+ } else {
+ if (memcmp(buffer, "stop", 4) == 0)
+ {
+ printk(KERN_WARNING "record mtd erase and write stop\n");
+ record_mtd_trigger_flag = 0;
+ }
+ else
+ {
+ return -EINVAL;
+ }
+ }
+
+ return count;
+}
+
+static int proc_record_mtd_erase_times_show(struct seq_file *m, void *v)
+{
+ seq_printf(m, "mtd:%s\n", g_zxic_mtd_record.name);
+ seq_printf(m, "erase_times:%u\n", g_zxic_mtd_record.erase_times);
+ seq_printf(m, "write_times:%u\n", g_zxic_mtd_record.write_times);
+ return 0;
+}
+
+static int proc_record_mtd_erase_times_open(struct inode *inode, struct file *file)
+{
+ return single_open(file, proc_record_mtd_erase_times_show, NULL);
+}
+
+static const struct file_operations proc_record_mtd_name_fops = {
+ .read = proc_record_mtd_name_read,
+ .write = proc_record_mtd_name_write,
+};
+
+static const struct file_operations proc_record_mtd_trigger_fops = {
+ .read = proc_record_mtd_trigger_read,
+ .write = proc_record_mtd_trigger_write,
+};
+
+static const struct file_operations proc_record_mtd_erase_times_fops = {
+ .open = proc_record_mtd_erase_times_open,
+ .read = seq_read,
+ .llseek = seq_lseek,
+ .release = single_release,
+};
+
+static int zxic_record_proc_init(void)
+{
+ proc_record_mtd_name = proc_create("record_mtd_name", 0666, NULL, &proc_record_mtd_name_fops);
+ if (!proc_record_mtd_name)
+ return -ENOMEM;
+ proc_record_mtd_trigger = proc_create("record_mtd_trigger", 0666, NULL, &proc_record_mtd_trigger_fops);
+ if (!proc_record_mtd_trigger)
+ return -ENOMEM;
+ proc_record_mtd_erase_times = proc_create("record_mtd_erase_times", 0, NULL, &proc_record_mtd_erase_times_fops);
+ if (!proc_record_mtd_erase_times)
+ return -ENOMEM;
+ return 0;
+}
+/* Ended by AICoder, pid:5fc9ey6dc555c241432c0bd800e0358e8d683380 */
+
static int __init init_mtd(void)
{
int ret;
@@ -1111,6 +1243,8 @@
ret = mtd_bdi_init(&mtd_bdi_rw_mappable, "mtd-rwmap");
if (ret)
goto err_bdi3;
+ if (zxic_record_proc_init() < 0)
+ printk(KERN_ERR "zxic_record_proc_init error\n");
#ifdef CONFIG_PROC_FS
proc_mtd = proc_create("mtd", 0, NULL, &mtd_proc_ops);
diff --git a/ap/os/linux/linux-3.4.x/drivers/net/wireless/aic8800d80l/wifi_dev_aic88.c b/ap/os/linux/linux-3.4.x/drivers/net/wireless/aic8800d80l/wifi_dev_aic88.c
index e34d57c..c4f7076 100755
--- a/ap/os/linux/linux-3.4.x/drivers/net/wireless/aic8800d80l/wifi_dev_aic88.c
+++ b/ap/os/linux/linux-3.4.x/drivers/net/wireless/aic8800d80l/wifi_dev_aic88.c
@@ -5,6 +5,7 @@
#include <linux/miscdevice.h>
#include <asm/uaccess.h>
#include <linux/slab.h>
+#include <linux/delay.h>
#define WIFI_IOCTL_STOP 0x0
#define WIFI_IOCTL_START 0x1
diff --git a/ap/os/linux/linux-3.4.x/drivers/usb/dwc_otg/dwc_otg_driver.c b/ap/os/linux/linux-3.4.x/drivers/usb/dwc_otg/dwc_otg_driver.c
index 3c5fedb..2efcac2 100755
--- a/ap/os/linux/linux-3.4.x/drivers/usb/dwc_otg/dwc_otg_driver.c
+++ b/ap/os/linux/linux-3.4.x/drivers/usb/dwc_otg/dwc_otg_driver.c
@@ -59,6 +59,7 @@
#include <mach/zx29_usb.h>
#include <mach/highspeed_debug.h>
+#include <linux/android_notify.h>
#include <mach/pcu.h>
#include <linux/wakelock.h>
@@ -82,6 +83,8 @@
extern void dwc_otg_adp_start(dwc_otg_core_if_t * core_if, uint8_t is_host);
extern void zx297510_usbdev_init(void);
+extern void usb_record_dbginfo(usb_dbginfo_type inf_type, int status, int info_value);
+
/*-------------------------------------------------------------------------*/
/* Encapsulate the module parameter settings */
@@ -561,6 +564,32 @@
return IRQ_RETVAL(retval);
}
extern void dwc_otg_clk_enable(int isOn);
+/* Started by AICoder, pid:n296220457x77611403308a3f08a597015d84c3c */
+static struct workqueue_struct *dwc_otg_powerdown_queue;
+
+static void dwc_otg_powerdown_up(struct work_struct *work)
+{
+ USBHAL_DBG("dwc_otg_suspend_irq");
+ printk("dwc_otg_suspend_irq");
+ // dwc_otg_clk_enable(0);
+ dwc_otg_wakelock(0,1);
+ //usb_printk("%s, %u,wake_unlock, usbclk:0x%08x, USBMODCFG:0x%08x\n", __func__, __LINE__, *(volatile u32 *)(ZX_TOP_CRM_BASE+0x6C), *(volatile u32 *)(ZX29_USB20_MOD_CFG0));
+ zx_cpuidle_set_free(IDLE_FLAG_USB);
+
+ usb_record_dbginfo(USB_USB_SUSPEND, 1, 1);
+}
+static DECLARE_WORK(powerdown_up_work, dwc_otg_powerdown_up);
+
+static void dwc_otg_powerdown_down(struct work_struct *work)
+{
+ dwc_otg_wakelock(1,1);
+ zx_cpuidle_set_busy(IDLE_FLAG_USB);
+ USBHAL_DBG("dwc_otg_wakeup_irq");
+ printk("dwc_otg_wakeup_irq");
+ usb_record_dbginfo(USB_USB_RESUME, 1, 1);
+}
+static DECLARE_WORK(powerdown_down_work, dwc_otg_powerdown_down);
+
static irqreturn_t dwc_otg_suspend_irq(int irq, void *dev)
{
@@ -571,10 +600,11 @@
if(dwc_otg_device->irq_request== 1){
USBHAL_DBG("dwc_otg_suspend_irq");
printk("dwc_otg_suspend_irq");
-// dwc_otg_clk_enable(0);
- dwc_otg_wakelock(0,1);
- //usb_printk("%s, %u,wake_unlock, usbclk:0x%08x, USBMODCFG:0x%08x\n", __func__, __LINE__, *(volatile u32 *)(ZX_TOP_CRM_BASE+0x6C), *(volatile u32 *)(ZX29_USB20_MOD_CFG0));
- zx_cpuidle_set_free(IDLE_FLAG_USB);
+ if(dwc_otg_powerdown_queue){
+ queue_work(dwc_otg_powerdown_queue, &powerdown_up_work);
+ }else{
+ USBHAL_DBG("dwc_otg_wakeup_irq,dwc_otg_powerdown_queue is null, do nothing\n");
+ }
}
else{
USBHAL_DBG("dwc_otg_suspend_irq,clear pending\n");
@@ -591,11 +621,14 @@
// wake_lock(&dwc_otg_wake_lock);
if(dwc_otg_device->irq_request== 1){
- dwc_otg_wakelock(1,1);
- zx_cpuidle_set_busy(IDLE_FLAG_USB);
USBHAL_DBG("dwc_otg_wakeup_irq");
printk("dwc_otg_wakeup_irq");
// dwc_otg_clk_enable(1);
+ if(dwc_otg_powerdown_queue){
+ queue_work(dwc_otg_powerdown_queue, &powerdown_down_work);
+ }else{
+ USBHAL_DBG("dwc_otg_wakeup_irq,dwc_otg_powerdown_queue is null, can't add wakelock\n");
+ }
//usb_printk("%s, %u,wake_lock, usbclk:0x%08x, USBMODCFG:0x%08x\n", __func__, __LINE__, *(volatile u32 *)(ZX_TOP_CRM_BASE+0x6C), *(volatile u32 *)(ZX29_USB20_MOD_CFG0));
}
else{
@@ -604,7 +637,7 @@
}
return IRQ_RETVAL(retval);
}
-
+/* Ended by AICoder, pid:n296220457x77611403308a3f08a597015d84c3c */
extern unsigned int pm_get_usb_pdd_pending(void);
void dwc_otg_powerdown_irq_install(void)
{
@@ -1046,6 +1079,11 @@
/* we init a main wakelock for maintain system on until app start ok! */
wake_lock_init(&dwc_otg_wake_lock.wake_lock, WAKE_LOCK_SUSPEND, "dwc_otg_pm");
+ dwc_otg_powerdown_queue = create_singlethread_workqueue("dwc_otg_powerdown_work");
+ if (dwc_otg_powerdown_queue == NULL) {
+ pr_err("%s: failed to create dwc_otg_powerdown_queue\n", __func__);
+
+ }
return retval;
}
@@ -1064,7 +1102,10 @@
driver_remove_file(&dwc_otg_driver.driver, &driver_attr_version);
platform_driver_unregister(&dwc_otg_driver);
- wake_lock_destroy(&dwc_otg_wake_lock.wake_lock);
+ wake_lock_destroy(&dwc_otg_wake_lock.wake_lock);
+ if(dwc_otg_powerdown_queue){
+ destroy_workqueue(dwc_otg_powerdown_queue);
+ }
usb_printk("%s module removed\n", dwc_driver_name);
}
diff --git a/ap/os/linux/linux-3.4.x/drivers/watchdog/zx_soft_wdt.c b/ap/os/linux/linux-3.4.x/drivers/watchdog/zx_soft_wdt.c
index ebf9ea2..db7b7f8 100644
--- a/ap/os/linux/linux-3.4.x/drivers/watchdog/zx_soft_wdt.c
+++ b/ap/os/linux/linux-3.4.x/drivers/watchdog/zx_soft_wdt.c
@@ -53,12 +53,70 @@
#define WDT_REBOOT_RECORD_BASE (ZX_IRAM1_BASE+0x2410)
#define START_UP_STATUS_BASE (ZX_IRAM1_BASE+0x2420)
-#define USER_RESERVED_BASE (ZX_IRAM1_BASE+0x2424)
+#define USER_RESERVED_BASE (ZX_IRAM1_BASE+0x2424)
+#define OS_IRAM_STATISTIC_CNT (8)
+#define OS_IRAM_STATISTIC_CNT_C (5)
+#define OS_IRAM_STATISTIC_NAME_LEN (16)
+
+#define BASE_ADDR_STATISTIC_PSCPU (IRAM1_BASE_ADDR+0x2800) //IRAM1_A9_PSM_USE_BASE_ADDR+0x800
+#define BASE_LEN_STATISTIC_PSCPU (0x200UL)
+#define BASE_ADDR_STATISTIC_PHYCPU (BASE_ADDR_STATISTIC_PSCPU + BASE_LEN_STATISTIC_PSCPU)
+#define BASE_LEN_STATISTIC_PHYCPU (0x200UL)
+#define BASE_ADDR_STATISTIC_APCPU (BASE_ADDR_STATISTIC_PHYCPU + BASE_LEN_STATISTIC_PHYCPU)
+#define BASE_LEN_STATISTIC_APCPU (0x400UL)
+
+#define wdt_printk(fmt, args...) \
+{ \
+ printk(fmt, ##args); \
+ sc_debug_info_record(MODULE_ID_AP_REBOOT, fmt, ##args); \
+}
MODULE_AUTHOR("ZTE");
MODULE_LICENSE("GPL");
+typedef volatile struct {
+ unsigned int enable;
+ unsigned int cnt;
+ unsigned int index;
+ struct {
+ unsigned char name[OS_IRAM_STATISTIC_NAME_LEN];
+ unsigned int data2;
+ } statistics[OS_IRAM_STATISTIC_CNT];
+}t_iram_thread_statistic;
+
+typedef volatile struct {
+ unsigned int cnt;
+ unsigned int index;
+ struct {
+ unsigned int data1;
+ unsigned int data2;
+ } statistics[OS_IRAM_STATISTIC_CNT];
+}t_iram_statistic;
+
+typedef volatile struct {
+ unsigned int cnt;
+ unsigned int index;
+ struct {
+ unsigned char name[OS_IRAM_STATISTIC_NAME_LEN];
+ unsigned int data2;
+ } statistics[OS_IRAM_STATISTIC_CNT_C];
+}t_iram_thread_statistic_c;
+
+typedef volatile struct {
+ unsigned int cnt;
+ unsigned int index;
+ struct {
+ unsigned int data1;
+ unsigned int data2;
+ } statistics[OS_IRAM_STATISTIC_CNT_C];
+}t_iram_statistic_c;
+
+typedef struct
+{
+ char ramdump_reason[32]; //比如：ramdump_ap_appname
+ char kernel_reboot[32]; //比如：reboot_ap_appname
+} T_Reset_Reason;
typedef enum _T_WdtId
{
@@ -82,11 +140,29 @@
struct task_struct * current_task;
};
+#define THREAD_SWAPIN_PSCPU (BASE_ADDR_STATISTIC_PSCPU)
+#define IRQ_START_PSCPU (THREAD_SWAPIN_PSCPU + sizeof(t_iram_thread_statistic_c))
+#define IRQ_END_PSCPU (IRQ_START_PSCPU + sizeof(t_iram_statistic_c))
+//#define THREAD_SWAPIN_PHYCPU (BASE_ADDR_STATISTIC_PHYCPU)
+//#define IRQ_START_PHYCPU (THREAD_SWAPIN_PHYCPU + sizeof(t_iram_thread_statistic))
+//#define IRQ_END_PHYCPU (IRQ_START_PHYCPU + sizeof(t_iram_statistic))
+#define THREAD_SWAPIN_APCPU (BASE_ADDR_STATISTIC_APCPU)
+#define IRQ_START_APCPU (THREAD_SWAPIN_APCPU + sizeof(t_iram_thread_statistic))
+#define IRQ_END_APCPU (IRQ_START_APCPU + sizeof(t_iram_statistic))
+
static bool g_wdt_wakeup_flag = false;
static u32 g_wdt_wakeup_min_time = MAX_SLEEP_TIME;
static volatile u32 g_wdt_sleep_pre_time;
static unsigned int g_wdt_nv = 0;
-volatile unsigned int g_wdt_priority = 37;
+static volatile unsigned int g_wdt_priority = 37;
+
+static t_iram_thread_statistic_c *g_iram_swapin_statistic_cap = (t_iram_thread_statistic_c *)THREAD_SWAPIN_PSCPU;
+static t_iram_statistic_c *g_iram_irq_start_statistic_cap = (t_iram_statistic_c *)IRQ_START_PSCPU;
+static t_iram_statistic_c *g_iram_irq_end_statistic_cap = (t_iram_statistic_c *)IRQ_END_PSCPU;
+static t_iram_thread_statistic *g_iram_swapin_statistic_ap = (t_iram_thread_statistic *)THREAD_SWAPIN_APCPU;
+static t_iram_statistic *g_iram_irq_start_statistic_ap = (t_iram_statistic *)IRQ_START_APCPU;
+static t_iram_statistic *g_iram_irq_end_statistic_ap = (t_iram_statistic *)IRQ_END_APCPU;
+static T_Reset_Reason *g_iram_reset_reason_ap = (T_Reset_Reason *)(BASE_ADDR_STATISTIC_APCPU + BASE_LEN_STATISTIC_APCPU - sizeof(T_Reset_Reason));
#ifdef CONFIG_PREEMPT_RT_FULL
@@ -517,9 +593,11 @@
u32 wdt_reason=zx_read_reg(WDT_REBOOT_RECORD_BASE); //set at rpm
u32 status=zx_read_reg(START_UP_STATUS_BASE); //set at uboot
u32 user=zx_read_reg(USER_RESERVED_BASE); //set at uboot
-
+ u32 index=0;
char reason[20] ={0};
+ zx_write_reg(WDT_REBOOT_RECORD_BASE,0);
+
switch (wdt_reason)
{
case PS_WDT:
@@ -539,11 +617,63 @@
break;
}
- sc_debug_info_record(MODULE_ID_AP_REBOOT, "%s\n", reason);
- sc_debug_info_record(MODULE_ID_AP_REBOOT, "START_UP_STATUS:%x; USER_RESERVED:%x\n", status, user);
- printk( "%s", reason);
- printk( "START_UP_STATUS:%x; USER_RESERVED:%x\n", status, user);
+ wdt_printk("%s", reason);
+ wdt_printk("START_UP_STATUS:%x; USER_RESERVED:%x\n", status, user);
+ if (memcmp(g_iram_reset_reason_ap->ramdump_reason, "reset_", 6) == 0)
+ wdt_printk("last %s\n", g_iram_reset_reason_ap->ramdump_reason);
+ if (memcmp(g_iram_reset_reason_ap->kernel_reboot, "reset_", 6) == 0)
+ wdt_printk("last %s\n", g_iram_reset_reason_ap->kernel_reboot);
+
+ if(g_iram_swapin_statistic_cap->index <= OS_IRAM_STATISTIC_CNT_C)
+ {
+ wdt_printk("capcpuThread name, time, index is: %d;\n", g_iram_swapin_statistic_cap->index);
+ for(index =0; index < OS_IRAM_STATISTIC_CNT_C; index++ )
+ {
+ if(strlen(g_iram_swapin_statistic_cap->statistics[index].name))
+ wdt_printk("[NO.%d]%s, %d \n", index, g_iram_swapin_statistic_cap->statistics[index].name, g_iram_swapin_statistic_cap->statistics[index].data2 );
+ }
+
+ wdt_printk("capcpuIrqstart irqid, starttime, index is: %d\n", g_iram_irq_start_statistic_cap->index);
+ for(index =0; index < OS_IRAM_STATISTIC_CNT_C; index++ )
+ {
+ if(g_iram_irq_start_statistic_cap->statistics[index].data2)
+ wdt_printk("[NO.%d]%d, %d \n", index, g_iram_irq_start_statistic_cap->statistics[index].data1, g_iram_irq_start_statistic_cap->statistics[index].data2 );
+ }
+
+ wdt_printk("capcpuIrqend irqid, endtime, index is: %d\n", g_iram_irq_end_statistic_cap->index);
+ for(index =0; index < OS_IRAM_STATISTIC_CNT_C; index++ )
+ {
+ if(g_iram_irq_end_statistic_cap->statistics[index].data2)
+ wdt_printk("[NO.%d]%d, %d \n", index, g_iram_irq_end_statistic_cap->statistics[index].data1, g_iram_irq_end_statistic_cap->statistics[index].data2 );
+ }
+ }
+
+ if((g_iram_swapin_statistic_ap->enable == 1) && (g_iram_swapin_statistic_ap->index <= OS_IRAM_STATISTIC_CNT))
+ {
+ wdt_printk("apcpuThread name, time, index is:%d;\n", g_iram_swapin_statistic_ap->index);
+ for(index =0; index < OS_IRAM_STATISTIC_CNT; index++ )
+ {
+ if(strlen(g_iram_swapin_statistic_ap->statistics[index].name))
+ wdt_printk("[NO.%d]%s, %d \n", index, g_iram_swapin_statistic_ap->statistics[index].name, g_iram_swapin_statistic_ap->statistics[index].data2 );
+ }
+
+ wdt_printk("apcpuIrqstart irqid, starttime, index: %d\n", g_iram_irq_start_statistic_ap->index);
+ for(index =0; index < OS_IRAM_STATISTIC_CNT; index++ )
+ {
+ if(g_iram_irq_start_statistic_ap->statistics[index].data2)
+ wdt_printk("[NO.%d]%d, %d \n", index, g_iram_irq_start_statistic_ap->statistics[index].data1, g_iram_irq_start_statistic_ap->statistics[index].data2 );
+ }
+
+ wdt_printk("apcpuIrqend irqid, endtime, index is: %d\n", g_iram_irq_end_statistic_ap->index);
+ for(index =0; index < OS_IRAM_STATISTIC_CNT; index++ )
+ {
+ if(g_iram_irq_end_statistic_ap->statistics[index].data2)
+ wdt_printk("[NO.%d]%d, %d \n", index, g_iram_irq_end_statistic_ap->statistics[index].data1, g_iram_irq_end_statistic_ap->statistics[index].data2 );
+ }
+ }
+
+ memset((void *)(BASE_ADDR_STATISTIC_PSCPU), 0x0, 0x800);
}
diff --git a/ap/os/linux/linux-3.4.x/include/asm-generic/posix_types.h b/ap/os/linux/linux-3.4.x/include/asm-generic/posix_types.h
index a267e31..91d44bd 100644
--- a/ap/os/linux/linux-3.4.x/include/asm-generic/posix_types.h
+++ b/ap/os/linux/linux-3.4.x/include/asm-generic/posix_types.h
@@ -89,7 +89,7 @@
*/
typedef __kernel_long_t __kernel_off_t;
typedef long long __kernel_loff_t;
-typedef __kernel_ulong_t __kernel_time_t;
+typedef __kernel_long_t __kernel_time_t;
typedef __kernel_long_t __kernel_clock_t;
typedef int __kernel_timer_t;
typedef int __kernel_clockid_t;
diff --git a/ap/os/linux/linux-3.4.x/include/linux/ktime.h b/ap/os/linux/linux-3.4.x/include/linux/ktime.h
index 4d2dc89..76e01ab 100644
--- a/ap/os/linux/linux-3.4.x/include/linux/ktime.h
+++ b/ap/os/linux/linux-3.4.x/include/linux/ktime.h
@@ -48,9 +48,9 @@
#if BITS_PER_LONG != 64 && !defined(CONFIG_KTIME_SCALAR)
struct {
# ifdef __BIG_ENDIAN
- u32 sec, nsec;
+ s32 sec, nsec;
# else
- u32 nsec, sec;
+ s32 nsec, sec;
# endif
} tv;
#endif
@@ -71,20 +71,13 @@
*
* Return the ktime_t representation of the value
*/
-static inline ktime_t ktime_set(const unsigned long secs, const unsigned long nsecs)
+static inline ktime_t ktime_set(const long secs, const unsigned long nsecs)
{
#if (BITS_PER_LONG == 64)
if (unlikely(secs >= KTIME_SEC_MAX))
return (ktime_t){ .tv64 = KTIME_MAX };
#endif
- if (secs == -1)
- {
- return (ktime_t) { .tv64 = (s64)(signed long)secs * NSEC_PER_SEC + (s64)nsecs };
- }
- else
- {
- return (ktime_t) { .tv64 = (s64)secs * NSEC_PER_SEC + (s64)nsecs };
- }
+ return (ktime_t) { .tv64 = (s64)secs * NSEC_PER_SEC + (s64)nsecs };
}
/* Subtract two ktime_t variables. rem = lhs -rhs: */
@@ -148,7 +141,7 @@
*/
/* Set a ktime_t variable to a value in sec/nsec representation: */
-static inline ktime_t ktime_set(const unsigned long secs, const unsigned long nsecs)
+static inline ktime_t ktime_set(const long secs, const unsigned long nsecs)
{
return (ktime_t) { .tv = { .sec = secs, .nsec = nsecs } };
}
diff --git a/ap/os/linux/linux-3.4.x/include/linux/time.h b/ap/os/linux/linux-3.4.x/include/linux/time.h
index 941e1fd..bf1bb61 100644
--- a/ap/os/linux/linux-3.4.x/include/linux/time.h
+++ b/ap/os/linux/linux-3.4.x/include/linux/time.h
@@ -111,7 +111,7 @@
#if (BITS_PER_LONG == 64)
# define KTIME_SEC_MAX (KTIME_MAX / NSEC_PER_SEC)
#else
-# define KTIME_SEC_MAX ULONG_MAX
+# define KTIME_SEC_MAX LONG_MAX
#endif
/*
diff --git a/ap/os/linux/linux-3.4.x/kernel/tracker.c b/ap/os/linux/linux-3.4.x/kernel/tracker.c
index 0b5e76b..3518dee 100755
--- a/ap/os/linux/linux-3.4.x/kernel/tracker.c
+++ b/ap/os/linux/linux-3.4.x/kernel/tracker.c
@@ -60,6 +60,7 @@
#define OS_IRAM_SOFTIRQ_END (OS_IRAM_SOFTIRQ_START + sizeof(t_os_iram_statistic))
#define OS_IRAM_TIMER_START (OS_IRAM_SOFTIRQ_END + sizeof(t_os_iram_statistic))
#define OS_IRAM_TIMER_END (OS_IRAM_TIMER_START + sizeof(t_os_iram_statistic))
+#define OS_IRAM_RESET_REASON_START (OS_STATISTIC_IRAM_BASE + 0x400 - sizeof(T_Reset_Reason))
#endif
#define os_statistic_check() *((volatile unsigned long *)OS_STATISTIC_IRAM_BASE)
@@ -108,6 +109,12 @@
}T_LogIram_Record;
#endif
+typedef struct
+{
+ char ramdump_reason[32]; //±ÈÈ磺ramdump_ap_appname
+ char kernel_reboot[32]; //±ÈÈ磺reboot_ap_appname
+} T_Reset_Reason;
+
/*******************************************************************************
* È«¾Ö±äÁ¿ *
*******************************************************************************/
@@ -144,6 +151,7 @@
static t_os_ddr_statistic *g_os_ddr_softirq_end_statistic;
static t_os_ddr_statistic *g_os_ddr_timer_start_statistic;
static t_os_ddr_statistic *g_os_ddr_timer_end_statistic;
+volatile T_Reset_Reason *g_os_reset_reason;
#endif
#ifndef CONFIG_SYSTEM_CAP
@@ -461,6 +469,32 @@
os_statistic_in_ddr(g_os_ddr_timer_end_statistic, func, time);
os_statistic_info_update();
}
+/*
+reason: 1 for ramdump, 2 for kernel reboot
+cpu: ap/cap/rpm/phy
+app: current->comm
+*/
+/* Started by AICoder, pid:pf139dce4f7776c149ec081b508bae14e6084ede */
+void zxic_reset_reason(int reason, const char *cpu, const char *app)
+{
+ char buffer[32];
+
+ memset(buffer, 0, sizeof(buffer));
+ switch (reason)
+ {
+ case 1:
+ snprintf(buffer, 32, "reset_ramdump_%s_%s", cpu, app);
+ memcpy(g_os_reset_reason->ramdump_reason, buffer, sizeof(buffer));
+ break;
+ case 2:
+ snprintf(buffer, 32, "reset_kreboot_%s_%s", cpu, app);
+ memcpy(g_os_reset_reason->kernel_reboot, buffer, sizeof(buffer));
+ break;
+ default:
+ break;
+ }
+}
+/* Ended by AICoder, pid:pf139dce4f7776c149ec081b508bae14e6084ede */
#ifndef CONFIG_SYSTEM_CAP
@@ -558,6 +592,8 @@
#ifndef CONFIG_SYSTEM_CAP
proc_create("kernel_log_tracker", 0, NULL, &kernel_log_tracker_proc_fops);
#endif
+
+ g_os_reset_reason = (T_Reset_Reason *)OS_IRAM_RESET_REASON_START;
/*
init_timer(&timer);
timer.expires = jiffies + 40*HZ;//msecs_to_jiffies(40*1000);//ÑÓ³Ù40Ãë
diff --git a/ap/os/linux/linux-3.4.x/mm/ramdump/ramdump_trans_server.c b/ap/os/linux/linux-3.4.x/mm/ramdump/ramdump_trans_server.c
index bcf8ad7..2609ba0 100755
--- a/ap/os/linux/linux-3.4.x/mm/ramdump/ramdump_trans_server.c
+++ b/ap/os/linux/linux-3.4.x/mm/ramdump/ramdump_trans_server.c
@@ -138,6 +138,7 @@
extern void emergency_restart(void);
#endif
+extern void zxic_reset_reason(int reason, const char *cpu, const char *app);
extern void zx_wdt_m0_stop(void);
extern struct meminfo meminfo;
#ifdef _USE_VEHICLE_DC
@@ -568,6 +569,7 @@
static void ramdump_icp_msg_from_zsp(void *buf, unsigned int len)
{
ramdump_trans_server_force_panic_flag = RAMDUMP_CLIENT_ZSP;
+ zxic_reset_reason(1, "phy", "zsp");
ramdump_clients_icp_handle(buf, len);
}
@@ -600,6 +602,7 @@
void ramdump_icp_msg_from_m0(void *buf, int len)
{
ramdump_trans_server_force_panic_flag = RAMDUMP_CLIENT_M0;
+ zxic_reset_reason(1, "rpm", "m0");
OSS_PANIC("trans server received forced dump request from M0 client!\n");
}
@@ -716,14 +719,38 @@
* ·µ »Ø Öµ: ÊÇ·ñÌø¹ý
* ÆäËü˵Ã÷: This function is used for judge file is skip or not
*******************************************************************************/
+/* Started by AICoder, pid:z865016281f2eb61401a0bbbf042be1ce3921564 */
bool ramdump_file_skip(unsigned int index)
{
unsigned int cnt = 0;
- ramdump_shm_file_num = sizeof(ramdump_shm_export_file)/sizeof(ramdump_shm_export_file[0]);
+ ramdump_shm_file_num = sizeof(ramdump_shm_export_file) / sizeof(ramdump_shm_export_file[0]);
for (; cnt < ramdump_shm_file_num; cnt++) {
- if(strcmp(ramdump_trans_server_ram_conf[index].name, ramdump_shm_export_file[cnt]) == 0)
+ if (strcmp(ramdump_trans_server_ram_conf[index].name, ramdump_shm_export_file[cnt]) == 0) {
return true;
+ }
+ }
+ return false;
+}
+/* Ended by AICoder, pid:z865016281f2eb61401a0bbbf042be1ce3921564 */
+
+/*******************************************************************************
+* ¹¦ÄÜÃèÊö: ramdump_cmm_script_skip
+* ²ÎÊý˵Ã÷:
+* (´«Èë²ÎÊý) index
+* (´«³ö²ÎÊý) void
+* ·µ »Ø Öµ: ÊÇ·ñÌø¹ý
+* ÆäËü˵Ã÷: This function is used for judge file is skip or not
+*******************************************************************************/
+bool ramdump_cmm_script_skip(unsigned int index)
+{
+ char *ramconf_name = ramdump_trans_server_ram_conf[index].name;
+
+ if((strcmp(ramconf_name, "cap_ddr.bin") == 0)
+ || (strcmp(ramconf_name, "cap.cmm") == 0)
+ || (strcmp(ramconf_name, "cap_err_log.txt") == 0))
+ {
+ return true;
}
return false;
}
@@ -746,7 +773,8 @@
#ifdef _USE_VEHICLE_DC
if ((ramdump_export_mode == RAMDUMP_MODE_EMMC)
|| (ramdump_export_mode == RAMDUMP_MODE_SPINAND)){
- if (ramdump_file_skip(i_ram_conf) == true) {
+ if ((ramdump_file_skip(i_ram_conf) == true)
+ || (ramdump_cmm_script_skip(i_ram_conf) == true)){
i_ram_conf++;
continue;
}
@@ -1236,7 +1264,7 @@
RAMDUMP_CAP_LOG_BUF_ADDR,
RAMDUMP_CAP_LOG_BUF_LEN,
0,
- RAMDUMP_FLAG_LEVEL_LOW,
+ RAMDUMP_FLAG_LEVEL_HIGH,
0);
ramdump_ram_conf_table_add(
"rpmsg_cap.bin",
@@ -1304,6 +1332,8 @@
if (sysctl_ramdump_on_panic == FALSE)
printk(KERN_EMERG "Ramdump info: Ramdump disabled!\n");
printk(KERN_EMERG "Ramdump info: Current Process is: %s, pid is %i!\n", current->comm, current->pid);
+ if (ramdump_trans_server_force_panic_flag == RAMDUMP_FALSE)
+ zxic_reset_reason(1, "ap", current->comm); //ap ramdump
}
/*******************************************************************************