Merge pull request #4737 from mysterywolf/3,1,xformatv3.1.5

[lts 3.1.x] format codes

7 files changed, 501 insertions, 501 deletions

diff --git a/libcpu/unicore32/sep6200/cpu.c b/libcpu/unicore32/sep6200/cpu.c
index 01da33ad93..8d0b86dae3 100644
--- a/libcpu/unicore32/sep6200/cpu.c
+++ b/libcpu/unicore32/sep6200/cpu.c
@@ -20,23 +20,23 @@
 #ifdef __GNUC__
 rt_inline void cache_invalid(void)
 {
-	__asm__ volatile ("movc	p0.c5, r1, #28\n"
-			"nop;nop;nop;nop;nop;nop;nop;nop;\n"
-			:
-			:
-			:"memory", "cc"
-			);
+    __asm__ volatile ("movc p0.c5, r1, #28\n"
+            "nop;nop;nop;nop;nop;nop;nop;nop;\n"
+            :
+            :
+            :"memory", "cc"
+            );
 }
 
 rt_inline void cache_enable(void)
 {
-	__asm__ volatile ( "movc r1, p0.c1, #0\n"
-			"or r1, r1, #0xc\n"
-			"movc p0.c1, r1, #0\n"
-			"nop;nop;nop;nop;nop;nop;nop;nop;\n"
-			:
-			:
-			:"r0", "memory", "cc");
+    __asm__ volatile ( "movc r1, p0.c1, #0\n"
+            "or r1, r1, #0xc\n"
+            "movc p0.c1, r1, #0\n"
+            "nop;nop;nop;nop;nop;nop;nop;nop;\n"
+            :
+            :
+            :"r0", "memory", "cc");
 }
 
 rt_inline void clean_dcache(void)
@@ -45,8 +45,8 @@ rt_inline void clean_dcache(void)
                "movc p0.c5, ip, #10\n"
                "nop; nop; nop; nop; nop; nop; nop; nop\n"
                :
-	       :
-	       :"ip", "memory", "cc");
+           :
+           :"ip", "memory", "cc");
 }
 
 rt_inline rt_uint32_t icache_status(void)
@@ -77,7 +77,7 @@ rt_inline rt_uint32_t dcache_status(void)
 
 rt_inline void dcache_flush(void)
 {
-	__asm__ volatile ( "mov ip, #0\n"
+    __asm__ volatile ( "mov ip, #0\n"
               "movc p0.c5, ip, #14\n"
               "nop; nop; nop; nop; nop; nop; nop; nop\n"
               :
@@ -87,7 +87,7 @@ rt_inline void dcache_flush(void)
 
 rt_inline void icache_invalid(void)
 {
-	 __asm__ volatile ( "mov r0, #0\n"
+     __asm__ volatile ( "mov r0, #0\n"
                "movc p0.c5, r0, #20\n"
                "nop; nop; nop; nop; nop; nop; nop; nop\n"
                :
@@ -107,8 +107,8 @@ rt_inline void dcache_invalid(void)
 
 rt_inline void icache_disable(void)
 {
-	icache_invalid();
-	__asm__ volatile ( "movc r0, p0.c1, #0\n"
+    icache_invalid();
+    __asm__ volatile ( "movc r0, p0.c1, #0\n"
                "andn r0, r0, #8\n"
                "movc p0.c1, r0, #0\n"
                :
@@ -118,8 +118,8 @@ rt_inline void icache_disable(void)
 
 rt_inline void dcache_disable(void)
 {
-	dcache_flush();
-	__asm__ volatile ( "movc r0, p0.c1, #0\n"
+    dcache_flush();
+    __asm__ volatile ( "movc r0, p0.c1, #0\n"
                "andn r0, r0, #20\n"
                "movc p0.c1, r0, #0\n"
                :
@@ -170,7 +170,7 @@ rt_inline void dcache_enable(void)
  */
 void rt_hw_cpu_icache_enable()
 {
-	icache_enable();
+    icache_enable();
 }
 
 /**
@@ -179,7 +179,7 @@ void rt_hw_cpu_icache_enable()
  */
 void rt_hw_cpu_icache_disable()
 {
-	icache_disable();
+    icache_disable();
 }
 
 /**
@@ -188,7 +188,7 @@ void rt_hw_cpu_icache_disable()
  */
 rt_base_t rt_hw_cpu_icache_status()
 {
-	return icache_status();
+    return icache_status();
 }
 
 /**
@@ -197,7 +197,7 @@ rt_base_t rt_hw_cpu_icache_status()
  */
 void rt_hw_cpu_dcache_enable()
 {
-	dcache_enable();
+    dcache_enable();
 }
 
 /**
@@ -206,7 +206,7 @@ void rt_hw_cpu_dcache_enable()
  */
 void rt_hw_cpu_dcache_disable()
 {
-	dcache_disable();
+    dcache_disable();
 }
 
 /**
@@ -215,29 +215,29 @@ void rt_hw_cpu_dcache_disable()
  */
 rt_base_t rt_hw_cpu_dcache_status()
 {
-	return dcache_status();
+    return dcache_status();
 }
 
 static void sep6200_reset(rt_uint32_t addr)
 {
      __asm__ volatile ( "mov ip, #0\n"
-		     "movc p0.c5, ip, #28\n" /*Cache invalidate all*/
-		     "movc p0.c6, ip, #6\n" /*TLB invalidate all*/
-		     "nop;nop;nop;nop;nop;nop;nop;nop;\n"
-		     "movc ip, p0.c1, #0\n" /*ctrl register*/
-		     "andn ip, ip, #0x000f\n" /*disable caches and mmu*/
-		     "movc p0.c1, ip, #0\n"
-		     "nop\n"
-		     "mov pc, %0\n"
-		     "nop;nop;nop;nop;nop;nop;nop;nop;\n"
-		      : "=&r" (addr)
-		      :
-		      :"memory", "cc");
+             "movc p0.c5, ip, #28\n" /*Cache invalidate all*/
+             "movc p0.c6, ip, #6\n" /*TLB invalidate all*/
+             "nop;nop;nop;nop;nop;nop;nop;nop;\n"
+             "movc ip, p0.c1, #0\n" /*ctrl register*/
+             "andn ip, ip, #0x000f\n" /*disable caches and mmu*/
+             "movc p0.c1, ip, #0\n"
+             "nop\n"
+             "mov pc, %0\n"
+             "nop;nop;nop;nop;nop;nop;nop;nop;\n"
+              : "=&r" (addr)
+              :
+              :"memory", "cc");
 }
 
 static void sep6200_poweroff(void)
 {
-	rt_kprintf("sep6200 power off not implemented\n");
+    rt_kprintf("sep6200 power off not implemented\n");
   while(1);
 }
 
@@ -248,12 +248,12 @@ static void sep6200_poweroff(void)
 void rt_hw_cpu_reset()
 {
 
-	rt_kprintf("Soft reset, Restarting system...\n");
-	sep6200_reset(0);
+    rt_kprintf("Soft reset, Restarting system...\n");
+    sep6200_reset(0);
 
-	while(1);	/* loop forever and wait for reset to happen */
+    while(1);   /* loop forever and wait for reset to happen */
 
-	/* NEVER REACHED */
+    /* NEVER REACHED */
 }
 
 /**
@@ -262,15 +262,15 @@ void rt_hw_cpu_reset()
  */
 void rt_hw_cpu_shutdown()
 {
-	rt_uint32_t level;
-	rt_kprintf("shutdown...\n");
+    rt_uint32_t level;
+    rt_kprintf("shutdown...\n");
 
-	level = rt_hw_interrupt_disable();
-	sep6200_poweroff();
-	while (level)
-	{
-		RT_ASSERT(0);
-	}
+    level = rt_hw_interrupt_disable();
+    sep6200_poweroff();
+    while (level)
+    {
+        RT_ASSERT(0);
+    }
 }
 
 /*@}*/
diff --git a/libcpu/unicore32/sep6200/interrupt.c b/libcpu/unicore32/sep6200/interrupt.c
index 2737849903..b34e648630 100644
--- a/libcpu/unicore32/sep6200/interrupt.c
+++ b/libcpu/unicore32/sep6200/interrupt.c
@@ -12,38 +12,38 @@
 #include <rthw.h>
 #include <sep6200.h>
 
-#define MAX_HANDLERS	64
+#define MAX_HANDLERS    64
 
 
 #define SEP6200_IRQ_TYPE 0
 #define SEP6200_FIQ_TYPE 1
 
-#define int_enable_all() 					  \
-	do {							  \
-		*(volatile unsigned long*)SEP6200_VIC_INT_EN_L = ~0x0;\
-		*(volatile unsigned long*)SEP6200_VIC_INT_EN_H = ~0x0;\
-	}while(0)
-#define int_disable_all() 					 \
-	do {							 \
-		*(volatile unsigned long*)SEP6200_VIC_INT_EN_L = 0x0;\
-		*(volatile unsigned long*)SEP6200_VIC_INT_EN_H = 0x0;\
-	}while(0)
-#define mask_all_int(int_type)					 \
-	do {							 \
-		if (int_type == SEP6200_IRQ_TYPE){		 \
-		*(volatile unsigned long*)SEP6200_VIC_INT_MSK_ALL = 0x1;\
-		} else if (int_type == SEP6200_FIQ_TYPE) {\
-		*(volatile unsigned long*)SEP6200_VIC_INT_MSK_ALL = 0x2;\
-		}\
-	}while(0)
+#define int_enable_all()                      \
+    do {                              \
+        *(volatile unsigned long*)SEP6200_VIC_INT_EN_L = ~0x0;\
+        *(volatile unsigned long*)SEP6200_VIC_INT_EN_H = ~0x0;\
+    }while(0)
+#define int_disable_all()                    \
+    do {                             \
+        *(volatile unsigned long*)SEP6200_VIC_INT_EN_L = 0x0;\
+        *(volatile unsigned long*)SEP6200_VIC_INT_EN_H = 0x0;\
+    }while(0)
+#define mask_all_int(int_type)                   \
+    do {                             \
+        if (int_type == SEP6200_IRQ_TYPE){       \
+        *(volatile unsigned long*)SEP6200_VIC_INT_MSK_ALL = 0x1;\
+        } else if (int_type == SEP6200_FIQ_TYPE) {\
+        *(volatile unsigned long*)SEP6200_VIC_INT_MSK_ALL = 0x2;\
+        }\
+    }while(0)
 #define unmask_all_int(int_type)\
-	do {							 \
-		if (int_type == SEP6200_IRQ_TYPE){		 \
-		*(volatile unsigned long*)SEP6200_VIC_INT_MSK_ALL = ~0x1;\
-		} else if (int_type == SEP6200_FIQ_TYPE) {\
-		*(volatile unsigned long*)SEP6200_VIC_INT_MSK_ALL = ~0x2;\
-		}\
-	}while(0)
+    do {                             \
+        if (int_type == SEP6200_IRQ_TYPE){       \
+        *(volatile unsigned long*)SEP6200_VIC_INT_MSK_ALL = ~0x1;\
+        } else if (int_type == SEP6200_FIQ_TYPE) {\
+        *(volatile unsigned long*)SEP6200_VIC_INT_MSK_ALL = ~0x2;\
+        }\
+    }while(0)
 
 #define SEP6200_INT_SET(intnum)                                     \
 do{                                                                 \
@@ -99,27 +99,27 @@ void rt_hw_interrupt_umask(int irq);
 
 rt_inline void sep6200_irq_enable(rt_uint32_t irq)
 {
-	SEP6200_INT_ENABLE(irq);
+    SEP6200_INT_ENABLE(irq);
 }
 
 rt_inline void sep6200_irq_disable(rt_uint32_t irq)
 {
-	SEP6200_INT_DISABLE(irq);
+    SEP6200_INT_DISABLE(irq);
 }
 
 rt_inline void sep6200_irq_unmask(rt_uint32_t irq)
 {
-	SEP6200_INT_ENABLE(irq);
+    SEP6200_INT_ENABLE(irq);
 }
 
 rt_inline void sep6200_irq_mask(rt_uint32_t irq)
 {
-	SEP6200_INT_DISABLE(irq);
+    SEP6200_INT_DISABLE(irq);
 }
 rt_isr_handler_t rt_hw_interrupt_handle(rt_uint32_t vector)
 {
-	rt_kprintf("Unhandled interrupt %d occured!!!\n", vector);
-	return RT_NULL;
+    rt_kprintf("Unhandled interrupt %d occured!!!\n", vector);
+    return RT_NULL;
 }
 
 /**
@@ -127,26 +127,26 @@ rt_isr_handler_t rt_hw_interrupt_handle(rt_uint32_t vector)
  */
 void rt_hw_interrupt_init(void)
 {
-	rt_int32_t i;
-	register rt_uint32_t idx;
+    rt_int32_t i;
+    register rt_uint32_t idx;
 
 
-	/* init exceptions table */
-	for(idx=0; idx < MAX_HANDLERS; idx++)
-	{
-		isr_table[idx].handler = (rt_isr_handler_t)rt_hw_interrupt_handle;
-	}
-	int_disable_all();
-	mask_all_int(SEP6200_FIQ_TYPE);
+    /* init exceptions table */
+    for(idx=0; idx < MAX_HANDLERS; idx++)
+    {
+        isr_table[idx].handler = (rt_isr_handler_t)rt_hw_interrupt_handle;
+    }
+    int_disable_all();
+    mask_all_int(SEP6200_FIQ_TYPE);
 
-	//int_enable_all();
-	unmask_all_int(SEP6200_IRQ_TYPE);
+    //int_enable_all();
+    unmask_all_int(SEP6200_IRQ_TYPE);
 
-	/* init interrupt nest, and context in thread sp */
-	rt_interrupt_nest = 0;
-	rt_interrupt_from_thread = 0;
-	rt_interrupt_to_thread = 0;
-	rt_thread_switch_interrupt_flag = 0;
+    /* init interrupt nest, and context in thread sp */
+    rt_interrupt_nest = 0;
+    rt_interrupt_from_thread = 0;
+    rt_interrupt_to_thread = 0;
+    rt_thread_switch_interrupt_flag = 0;
 }
 
 
@@ -157,11 +157,11 @@ void rt_hw_interrupt_init(void)
  */
 void rt_hw_interrupt_mask(int irq)
 {
-	if (irq >= MAX_HANDLERS) {
-		rt_kprintf("Wrong irq num to mask\n");
-	} else {
-		sep6200_irq_mask(irq);
-	}
+    if (irq >= MAX_HANDLERS) {
+        rt_kprintf("Wrong irq num to mask\n");
+    } else {
+        sep6200_irq_mask(irq);
+    }
 
 }
 
@@ -171,11 +171,11 @@ void rt_hw_interrupt_mask(int irq)
  */
 void rt_hw_interrupt_umask(int irq)
 {
-	if (irq >= MAX_HANDLERS) {
-		rt_kprintf("Wrong irq num to unmask\n");
-	} else {
-		sep6200_irq_unmask(irq);
-	}
+    if (irq >= MAX_HANDLERS) {
+        rt_kprintf("Wrong irq num to unmask\n");
+    } else {
+        sep6200_irq_unmask(irq);
+    }
 }
 
 /**
@@ -196,7 +196,7 @@ rt_isr_handler_t rt_hw_interrupt_install(int vector, rt_isr_handler_t handler,
         if (handler != RT_NULL)
         {
 #ifdef RT_USING_INTERRUPT_INFO
-		    rt_strncpy(isr_table[vector].name, name, RT_NAME_MAX);
+            rt_strncpy(isr_table[vector].name, name, RT_NAME_MAX);
 #endif /* RT_USING_INTERRUPT_INFO */
             isr_table[vector].handler = handler;
             isr_table[vector].param = param;
diff --git a/libcpu/unicore32/sep6200/sep6200.h b/libcpu/unicore32/sep6200/sep6200.h
index 9aced7fbbb..773b505a02 100644
--- a/libcpu/unicore32/sep6200/sep6200.h
+++ b/libcpu/unicore32/sep6200/sep6200.h
@@ -15,58 +15,58 @@
 
 /*Core definations*/
 #define PRIVMODE  0x13
-#define	Mode_USR	0x10
-#define	Mode_REAL	0x11
-#define	Mode_IRQ	0x12
-#define	Mode_PRIV	0x13
-#define	Mode_TRAP	0x17
-#define	Mode_EXT	0x1B
-#define	Mode_SUSR	0x1F
+#define Mode_USR    0x10
+#define Mode_REAL   0x11
+#define Mode_IRQ    0x12
+#define Mode_PRIV   0x13
+#define Mode_TRAP   0x17
+#define Mode_EXT    0x1B
+#define Mode_SUSR   0x1F
 
 /*
  *  Address
  */
 
-#define	 SEP6200_VIC_BASE	0xb0000000
-#define  SEP6200_PMU_BASE	0xb0001000
-#define  SEP6200_RTC_BASE	0xb0002000
-#define	 SEP6200_TIMER_BASE 0xb0003000
-#define  SEP6200_PWM_BASE	0xb0004000
-#define  SEP6200_GPIO_BASE	0xb0006000
-#define  SEP6200_TOUCH_ADC	0xb0007000
-#define  SEP6200_SYSCTL_BASE	0xb0008000
-#define  SEP6200_UART0_BASE	0xb1000000
-#define  SEP6200_UART1_BASE	0xb1001000
-#define  SEP6200_UART2_BASE	0xb1002000
-#define  SEP6200_UART3_BASE	0xb1003000
-#define	 SEP6200_SSI1_BASE	0xb1004000
-#define	 SEP6200_SSI2_BASE	0xb1005000
-#define	 SEP6200_SSI3_BASE	0xb1006000
-#define  SEP6200_I2C_BASE	0xb1007000
-#define  SEP6200_I2S_BASE	0xb1008000
+#define  SEP6200_VIC_BASE   0xb0000000
+#define  SEP6200_PMU_BASE   0xb0001000
+#define  SEP6200_RTC_BASE   0xb0002000
+#define  SEP6200_TIMER_BASE 0xb0003000
+#define  SEP6200_PWM_BASE   0xb0004000
+#define  SEP6200_GPIO_BASE  0xb0006000
+#define  SEP6200_TOUCH_ADC  0xb0007000
+#define  SEP6200_SYSCTL_BASE    0xb0008000
+#define  SEP6200_UART0_BASE 0xb1000000
+#define  SEP6200_UART1_BASE 0xb1001000
+#define  SEP6200_UART2_BASE 0xb1002000
+#define  SEP6200_UART3_BASE 0xb1003000
+#define  SEP6200_SSI1_BASE  0xb1004000
+#define  SEP6200_SSI2_BASE  0xb1005000
+#define  SEP6200_SSI3_BASE  0xb1006000
+#define  SEP6200_I2C_BASE   0xb1007000
+#define  SEP6200_I2S_BASE   0xb1008000
 #define  SEP6200_USB_BASE    0xb1010000
 #define  SEP6200_DMAC2_BASE  0xb1011000
 #define  SEP6200_ESRAM_BASE  0xb2000000
-#define	 SEP6200_NORREG_BASE0xb2020000
-#define	 SEP6200_SDIO1_BASE	0xb2022000
-#define	 SEP6200_SDIO2_BASE	0xb2023000
-#define	 SEP6200_LCDC_BASE	0xb2025000
-#define	 SEP6200_VPU_BASE	0xb2026000
-#define	 SEP6200_DMAC1_BASE	0xb2027000
-#define	 SEP6200_DDR2_REG	0xb3000000
-#define	 SEP6200_DDR_MEM	0x40000000
+#define  SEP6200_NORREG_BASE0xb2020000
+#define  SEP6200_SDIO1_BASE 0xb2022000
+#define  SEP6200_SDIO2_BASE 0xb2023000
+#define  SEP6200_LCDC_BASE  0xb2025000
+#define  SEP6200_VPU_BASE   0xb2026000
+#define  SEP6200_DMAC1_BASE 0xb2027000
+#define  SEP6200_DDR2_REG   0xb3000000
+#define  SEP6200_DDR_MEM    0x40000000
 
-#define SEP6200_UART0_DLBL	(SEP6200_UART0_BASE+0x00)
-#define SEP6200_UART0_RXFIFO	(SEP6200_UART0_BASE+0x00)
-#define SEP6200_UART0_TXFIFO	(SEP6200_UART0_BASE+0x00)
-#define SEP6200_UART0_DLBH	(SEP6200_UART0_BASE+0x04)
-#define SEP6200_UART0_IER	(SEP6200_UART0_BASE+0x04)
-#define SEP6200_UART0_IIR	(SEP6200_UART0_BASE+0x08)
-#define SEP6200_UART0_FCR	(SEP6200_UART0_BASE+0x08)
-#define SEP6200_UART0_LCR	(SEP6200_UART0_BASE+0x0c)
-#define SEP6200_UART0_MCR	(SEP6200_UART0_BASE+0x10)
-#define SEP6200_UART0_LSR	(SEP6200_UART0_BASE+0x14)
-#define SEP6200_UART0_MSR	(SEP6200_UART0_BASE+0x18)
+#define SEP6200_UART0_DLBL  (SEP6200_UART0_BASE+0x00)
+#define SEP6200_UART0_RXFIFO    (SEP6200_UART0_BASE+0x00)
+#define SEP6200_UART0_TXFIFO    (SEP6200_UART0_BASE+0x00)
+#define SEP6200_UART0_DLBH  (SEP6200_UART0_BASE+0x04)
+#define SEP6200_UART0_IER   (SEP6200_UART0_BASE+0x04)
+#define SEP6200_UART0_IIR   (SEP6200_UART0_BASE+0x08)
+#define SEP6200_UART0_FCR   (SEP6200_UART0_BASE+0x08)
+#define SEP6200_UART0_LCR   (SEP6200_UART0_BASE+0x0c)
+#define SEP6200_UART0_MCR   (SEP6200_UART0_BASE+0x10)
+#define SEP6200_UART0_LSR   (SEP6200_UART0_BASE+0x14)
+#define SEP6200_UART0_MSR   (SEP6200_UART0_BASE+0x18)
 
 
 #define    SEP6200_TIMER_T1LCR              (SEP6200_TIMER_BASE + 0X000)
@@ -348,7 +348,7 @@ typedef    void                 (*FP)();   /* program start address */
 
 #ifndef    _BOOL_TYPE_
 #define    _BOOL_TYPE_
-typedef    int                  BOOL;	     /* Boolean value.  TRUE (1) or FALSE (0). */
+typedef    int                  BOOL;        /* Boolean value.  TRUE (1) or FALSE (0). */
 #endif
 
 typedef    int                  ER;         /* Error code.  A signed integer. */
@@ -368,88 +368,88 @@ typedef    int                  ER;         /* Error code.  A signed integer. */
 /*Macros for debug*/
 
 #define EOUT(fmt,...) \
-	do \
-	{ 	\
-		rt_kprintf("EOUT:(%s:%i)  ",__FILE__,__LINE__); \
-		rt_kprintf(fmt,##__VA_ARGS__); \
-	}while(0)
+    do \
+    {   \
+        rt_kprintf("EOUT:(%s:%i)  ",__FILE__,__LINE__); \
+        rt_kprintf(fmt,##__VA_ARGS__); \
+    }while(0)
 
 #define RT_DEBUG
 #ifdef RT_DEBUG
-	#define DBOUT(fmt,...) \
-	do \
-	{ 	\
-		rt_kprintf("DBOUT:(%s:%i)  ",__FILE__,__LINE__); \
-		rt_kprintf(fmt,##__VA_ARGS__); \
-	}while(0)
+    #define DBOUT(fmt,...) \
+    do \
+    {   \
+        rt_kprintf("DBOUT:(%s:%i)  ",__FILE__,__LINE__); \
+        rt_kprintf(fmt,##__VA_ARGS__); \
+    }while(0)
 #else
-	#define DBOUT(fmt,...) \
-	do{}while(0)
+    #define DBOUT(fmt,...) \
+    do{}while(0)
 #endif
 
-#ifdef	RT_DEBUG
-	#define ASSERT(arg) \
-	if((arg) == 0) \
-	{		\
-		while(1) \
-		{		  \
-			rt_kprintf("have a assert failure\n"); \
-		}										 \
-	}
+#ifdef  RT_DEBUG
+    #define ASSERT(arg) \
+    if((arg) == 0) \
+    {       \
+        while(1) \
+        {         \
+            rt_kprintf("have a assert failure\n"); \
+        }                                        \
+    }
 #else
-	#define ASSERT(arg) \
-	do		\
-	{		 \
-	}while(0)
+    #define ASSERT(arg) \
+    do      \
+    {        \
+    }while(0)
 #endif
 
 
 #define write_reg(reg,value) \
-	do \
-	{ \
-		*(RP)(reg) = value; \
-	}while(0)
+    do \
+    { \
+        *(RP)(reg) = value; \
+    }while(0)
 
 #define read_reg(reg) (*(RP)reg)
 
 
 struct rt_hw_register
 {
-	rt_uint32_t r0;
-	rt_uint32_t r1;
-	rt_uint32_t r2;
-	rt_uint32_t r3;
-	rt_uint32_t r4;
-	rt_uint32_t r5;
-	rt_uint32_t r6;
-	rt_uint32_t r7;
-	rt_uint32_t r8;
-	rt_uint32_t r9;
-	rt_uint32_t r10;
-	rt_uint32_t r11;
-	rt_uint32_t r12;
-	rt_uint32_t r13;
-	rt_uint32_t r14;
-	rt_uint32_t r15;
-	rt_uint32_t r16;
-	rt_uint32_t r17;
-	rt_uint32_t r18;
-	rt_uint32_t r19;
-	rt_uint32_t r20;
-	rt_uint32_t r21;
-	rt_uint32_t r22;
-	rt_uint32_t r23;
-	rt_uint32_t r24;
-	rt_uint32_t sb;
-	rt_uint32_t sl;
-	rt_uint32_t fp;
-	rt_uint32_t ip;
-	rt_uint32_t sp;
-	rt_uint32_t lr;
-	rt_uint32_t pc;
-	rt_uint32_t asr;
-	rt_uint32_t bsr;
-	rt_uint32_t ORIG_r0;
+    rt_uint32_t r0;
+    rt_uint32_t r1;
+    rt_uint32_t r2;
+    rt_uint32_t r3;
+    rt_uint32_t r4;
+    rt_uint32_t r5;
+    rt_uint32_t r6;
+    rt_uint32_t r7;
+    rt_uint32_t r8;
+    rt_uint32_t r9;
+    rt_uint32_t r10;
+    rt_uint32_t r11;
+    rt_uint32_t r12;
+    rt_uint32_t r13;
+    rt_uint32_t r14;
+    rt_uint32_t r15;
+    rt_uint32_t r16;
+    rt_uint32_t r17;
+    rt_uint32_t r18;
+    rt_uint32_t r19;
+    rt_uint32_t r20;
+    rt_uint32_t r21;
+    rt_uint32_t r22;
+    rt_uint32_t r23;
+    rt_uint32_t r24;
+    rt_uint32_t sb;
+    rt_uint32_t sl;
+    rt_uint32_t fp;
+    rt_uint32_t ip;
+    rt_uint32_t sp;
+    rt_uint32_t lr;
+    rt_uint32_t pc;
+    rt_uint32_t asr;
+    rt_uint32_t bsr;
+    rt_uint32_t ORIG_r0;
 };
 
 /*@}*/
diff --git a/libcpu/unicore32/sep6200/serial.c b/libcpu/unicore32/sep6200/serial.c
index 9b594d87be..f91834b6a7 100644
--- a/libcpu/unicore32/sep6200/serial.c
+++ b/libcpu/unicore32/sep6200/serial.c
@@ -5,7 +5,7 @@
  *
  * Change Logs:
  * Date           Author       Notes
- * 2013-03-16	    Peng Fan     Modified from sep4020
+ * 2013-03-16       Peng Fan     Modified from sep4020
  */
 #include <rtthread.h>
 #include <rthw.h>
@@ -22,204 +22,204 @@
  */
 static rt_err_t rt_serial_init (rt_device_t dev)
 {
-	struct serial_device* uart = (struct serial_device*) dev->user_data;
+    struct serial_device* uart = (struct serial_device*) dev->user_data;
 
-	if (!(dev->flag & RT_DEVICE_FLAG_ACTIVATED))
-	{
+    if (!(dev->flag & RT_DEVICE_FLAG_ACTIVATED))
+    {
 
-		if (dev->flag & RT_DEVICE_FLAG_INT_RX)
-		{
-			rt_memset(uart->int_rx->rx_buffer, 0,
-				sizeof(uart->int_rx->rx_buffer));
-			uart->int_rx->read_index = uart->int_rx->save_index = 0;
-		}
+        if (dev->flag & RT_DEVICE_FLAG_INT_RX)
+        {
+            rt_memset(uart->int_rx->rx_buffer, 0,
+                sizeof(uart->int_rx->rx_buffer));
+            uart->int_rx->read_index = uart->int_rx->save_index = 0;
+        }
 
-		if (dev->flag & RT_DEVICE_FLAG_INT_TX)
-		{
-			rt_memset(uart->int_tx->tx_buffer, 0,
-				sizeof(uart->int_tx->tx_buffer));
-			uart->int_tx->write_index = uart->int_tx->save_index = 0;
-		}
+        if (dev->flag & RT_DEVICE_FLAG_INT_TX)
+        {
+            rt_memset(uart->int_tx->tx_buffer, 0,
+                sizeof(uart->int_tx->tx_buffer));
+            uart->int_tx->write_index = uart->int_tx->save_index = 0;
+        }
 
-		dev->flag |= RT_DEVICE_FLAG_ACTIVATED;
-	}
+        dev->flag |= RT_DEVICE_FLAG_ACTIVATED;
+    }
 
-	return RT_EOK;
+    return RT_EOK;
 }
 
 /* save a char to serial buffer */
 static void rt_serial_savechar(struct serial_device* uart, char ch)
 {
-	rt_base_t level;
+    rt_base_t level;
 
-	/* disable interrupt */
-	level = rt_hw_interrupt_disable();
+    /* disable interrupt */
+    level = rt_hw_interrupt_disable();
 
-	uart->int_rx->rx_buffer[uart->int_rx->save_index] = ch;
-	uart->int_rx->save_index ++;
-	if (uart->int_rx->save_index >= UART_RX_BUFFER_SIZE)
-		uart->int_rx->save_index = 0;
+    uart->int_rx->rx_buffer[uart->int_rx->save_index] = ch;
+    uart->int_rx->save_index ++;
+    if (uart->int_rx->save_index >= UART_RX_BUFFER_SIZE)
+        uart->int_rx->save_index = 0;
 
-	/* if the next position is read index, discard this 'read char' */
-	if (uart->int_rx->save_index == uart->int_rx->read_index)
-	{
-		uart->int_rx->read_index ++;
-		if (uart->int_rx->read_index >= UART_RX_BUFFER_SIZE)
-			uart->int_rx->read_index = 0;
-	}
+    /* if the next position is read index, discard this 'read char' */
+    if (uart->int_rx->save_index == uart->int_rx->read_index)
+    {
+        uart->int_rx->read_index ++;
+        if (uart->int_rx->read_index >= UART_RX_BUFFER_SIZE)
+            uart->int_rx->read_index = 0;
+    }
 
-	/* enable interrupt */
-	rt_hw_interrupt_enable(level);
+    /* enable interrupt */
+    rt_hw_interrupt_enable(level);
 }
 
 static rt_err_t rt_serial_open(rt_device_t dev, rt_uint16_t oflag)
 {
-	RT_ASSERT(dev != RT_NULL);
-	return RT_EOK;
+    RT_ASSERT(dev != RT_NULL);
+    return RT_EOK;
 }
 
 static rt_err_t rt_serial_close(rt_device_t dev)
 {
-	RT_ASSERT(dev != RT_NULL);
-	return RT_EOK;
+    RT_ASSERT(dev != RT_NULL);
+    return RT_EOK;
 }
 
 static rt_size_t rt_serial_read (rt_device_t dev, rt_off_t pos, void* buffer, rt_size_t size)
 {
-	rt_uint8_t* ptr;
-	rt_err_t err_code;
-	struct serial_device* uart;
+    rt_uint8_t* ptr;
+    rt_err_t err_code;
+    struct serial_device* uart;
 
-	ptr = buffer;
-	err_code = RT_EOK;
-	uart = (struct serial_device*)dev->user_data;
+    ptr = buffer;
+    err_code = RT_EOK;
+    uart = (struct serial_device*)dev->user_data;
 
-	if (dev->flag & RT_DEVICE_FLAG_INT_RX)
-	{
-		rt_base_t level;
+    if (dev->flag & RT_DEVICE_FLAG_INT_RX)
+    {
+        rt_base_t level;
 
-		/* interrupt mode Rx */
-		while (size)
-		{
-			if (uart->int_rx->read_index != uart->int_rx->save_index)
-			{
-				*ptr++ = uart->int_rx->rx_buffer[uart->int_rx->read_index];
-				size --;
+        /* interrupt mode Rx */
+        while (size)
+        {
+            if (uart->int_rx->read_index != uart->int_rx->save_index)
+            {
+                *ptr++ = uart->int_rx->rx_buffer[uart->int_rx->read_index];
+                size --;
 
-				/* disable interrupt */
-				level = rt_hw_interrupt_disable();
+                /* disable interrupt */
+                level = rt_hw_interrupt_disable();
 
-				uart->int_rx->read_index ++;
-				if (uart->int_rx->read_index >= UART_RX_BUFFER_SIZE)
-					uart->int_rx->read_index = 0;
+                uart->int_rx->read_index ++;
+                if (uart->int_rx->read_index >= UART_RX_BUFFER_SIZE)
+                    uart->int_rx->read_index = 0;
 
-				/* enable interrupt */
-				rt_hw_interrupt_enable(level);
-			}
-			else
-			{
-				/* set error code */
-				err_code = -RT_EEMPTY;
-				break;
-			}
-		}
-	}
-	else
-	{
-		/* polling mode */
-		while ((rt_uint32_t)ptr - (rt_uint32_t)buffer < size)
-		{
-			while (uart->uart_device->lsr & USTAT_RCV_READY)
-			{
-				*ptr = uart->uart_device->dlbl_fifo.txfifo & 0xff;
-				ptr ++;
-			}
-		}
-	}
+                /* enable interrupt */
+                rt_hw_interrupt_enable(level);
+            }
+            else
+            {
+                /* set error code */
+                err_code = -RT_EEMPTY;
+                break;
+            }
+        }
+    }
+    else
+    {
+        /* polling mode */
+        while ((rt_uint32_t)ptr - (rt_uint32_t)buffer < size)
+        {
+            while (uart->uart_device->lsr & USTAT_RCV_READY)
+            {
+                *ptr = uart->uart_device->dlbl_fifo.txfifo & 0xff;
+                ptr ++;
+            }
+        }
+    }
 
-	/* set error code */
-	rt_set_errno(err_code);
-	return (rt_uint32_t)ptr - (rt_uint32_t)buffer;
+    /* set error code */
+    rt_set_errno(err_code);
+    return (rt_uint32_t)ptr - (rt_uint32_t)buffer;
 }
 
 static rt_size_t rt_serial_write (rt_device_t dev, rt_off_t pos, const void* buffer, rt_size_t size)
 {
-	rt_uint8_t* ptr;
-	rt_err_t err_code;
-	struct serial_device* uart;
+    rt_uint8_t* ptr;
+    rt_err_t err_code;
+    struct serial_device* uart;
 
-	err_code = RT_EOK;
-	ptr = (rt_uint8_t*)buffer;
-	uart = (struct serial_device*)dev->user_data;
+    err_code = RT_EOK;
+    ptr = (rt_uint8_t*)buffer;
+    uart = (struct serial_device*)dev->user_data;
 
-	if (dev->flag & RT_DEVICE_FLAG_INT_TX)
-	{
-		/* interrupt mode Tx */
-		while (uart->int_tx->save_index != uart->int_tx->write_index)
-		{
-			/* save on tx buffer */
-			uart->int_tx->tx_buffer[uart->int_tx->save_index] = *ptr++;
+    if (dev->flag & RT_DEVICE_FLAG_INT_TX)
+    {
+        /* interrupt mode Tx */
+        while (uart->int_tx->save_index != uart->int_tx->write_index)
+        {
+            /* save on tx buffer */
+            uart->int_tx->tx_buffer[uart->int_tx->save_index] = *ptr++;
 
-			-- size;
+            -- size;
 
-			/* move to next position */
-			uart->int_tx->save_index ++;
+            /* move to next position */
+            uart->int_tx->save_index ++;
 
-			/* wrap save index */
-			if (uart->int_tx->save_index >= UART_TX_BUFFER_SIZE)
-				uart->int_tx->save_index = 0;
-		}
+            /* wrap save index */
+            if (uart->int_tx->save_index >= UART_TX_BUFFER_SIZE)
+                uart->int_tx->save_index = 0;
+        }
 
-		/* set error code */
-		if (size > 0)
-			err_code = -RT_EFULL;
-	}
-	else
-	{
-		/* polling mode */
-		while (size)
-		{
-			/*
-			 * to be polite with serial console add a line feed
-			 * to the carriage return character
-			 */
-			if (*ptr == '\n' && (dev->flag & RT_DEVICE_FLAG_STREAM))
-			{
-				while (!(uart->uart_device->lsr & USTAT_TXB_EMPTY));
-				uart->uart_device->dlbl_fifo.txfifo = '\r';
-			}
+        /* set error code */
+        if (size > 0)
+            err_code = -RT_EFULL;
+    }
+    else
+    {
+        /* polling mode */
+        while (size)
+        {
+            /*
+             * to be polite with serial console add a line feed
+             * to the carriage return character
+             */
+            if (*ptr == '\n' && (dev->flag & RT_DEVICE_FLAG_STREAM))
+            {
+                while (!(uart->uart_device->lsr & USTAT_TXB_EMPTY));
+                uart->uart_device->dlbl_fifo.txfifo = '\r';
+            }
 
-			while (!(uart->uart_device->lsr & USTAT_TXB_EMPTY));
-			uart->uart_device->dlbl_fifo.txfifo = (*ptr & 0x1FF);
+            while (!(uart->uart_device->lsr & USTAT_TXB_EMPTY));
+            uart->uart_device->dlbl_fifo.txfifo = (*ptr & 0x1FF);
 
-			++ptr; --size;
-		}
-	}
+            ++ptr; --size;
+        }
+    }
 
-	/* set error code */
-	rt_set_errno(err_code);
+    /* set error code */
+    rt_set_errno(err_code);
 
-	return (rt_uint32_t)ptr - (rt_uint32_t)buffer;
+    return (rt_uint32_t)ptr - (rt_uint32_t)buffer;
 }
 
 static rt_err_t rt_serial_control (rt_device_t dev, int cmd, void *args)
 {
-	RT_ASSERT(dev != RT_NULL);
+    RT_ASSERT(dev != RT_NULL);
 
-	switch (cmd)
-	{
-	case RT_DEVICE_CTRL_SUSPEND:
-		/* suspend device */
-		dev->flag |= RT_DEVICE_FLAG_SUSPENDED;
-		break;
+    switch (cmd)
+    {
+    case RT_DEVICE_CTRL_SUSPEND:
+        /* suspend device */
+        dev->flag |= RT_DEVICE_FLAG_SUSPENDED;
+        break;
 
-	case RT_DEVICE_CTRL_RESUME:
-		/* resume device */
-		dev->flag &= ~RT_DEVICE_FLAG_SUSPENDED;
-		break;
-	}
+    case RT_DEVICE_CTRL_RESUME:
+        /* resume device */
+        dev->flag &= ~RT_DEVICE_FLAG_SUSPENDED;
+        break;
+    }
 
-	return RT_EOK;
+    return RT_EOK;
 }
 
 /*
@@ -227,49 +227,49 @@ static rt_err_t rt_serial_control (rt_device_t dev, int cmd, void *args)
  */
 rt_err_t rt_hw_serial_register(rt_device_t device, const char* name, rt_uint32_t flag, struct serial_device *serial)
 {
-	RT_ASSERT(device != RT_NULL);
+    RT_ASSERT(device != RT_NULL);
 
-	device->type 		= RT_Device_Class_Char;
-	device->rx_indicate = RT_NULL;
-	device->tx_complete = RT_NULL;
-	device->init 		= rt_serial_init;
-	device->open		= rt_serial_open;
-	device->close		= rt_serial_close;
-	device->read 		= rt_serial_read;
-	device->write 		= rt_serial_write;
-	device->control 	= rt_serial_control;
-	device->user_data   = serial;
+    device->type        = RT_Device_Class_Char;
+    device->rx_indicate = RT_NULL;
+    device->tx_complete = RT_NULL;
+    device->init        = rt_serial_init;
+    device->open        = rt_serial_open;
+    device->close       = rt_serial_close;
+    device->read        = rt_serial_read;
+    device->write       = rt_serial_write;
+    device->control     = rt_serial_control;
+    device->user_data   = serial;
 
-	/* register a character device */
-	return rt_device_register(device, name, RT_DEVICE_FLAG_RDWR | flag);
+    /* register a character device */
+    return rt_device_register(device, name, RT_DEVICE_FLAG_RDWR | flag);
 }
 
 /* ISR for serial interrupt */
 void rt_hw_serial_isr(rt_device_t device)
 {
-	struct serial_device* uart = (struct serial_device*) device->user_data;
+    struct serial_device* uart = (struct serial_device*) device->user_data;
 
-	/* interrupt mode receive */
-	RT_ASSERT(device->flag & RT_DEVICE_FLAG_INT_RX);
+    /* interrupt mode receive */
+    RT_ASSERT(device->flag & RT_DEVICE_FLAG_INT_RX);
 
-	/* save on rx buffer */
-	while (uart->uart_device->lsr & USTAT_RCV_READY)
-	{
-		rt_serial_savechar(uart, uart->uart_device->dlbl_fifo.rxfifo & 0xff);
-	}
+    /* save on rx buffer */
+    while (uart->uart_device->lsr & USTAT_RCV_READY)
+    {
+        rt_serial_savechar(uart, uart->uart_device->dlbl_fifo.rxfifo & 0xff);
+    }
 
-	/* invoke callback */
-	if (device->rx_indicate != RT_NULL)
-	{
-		rt_size_t rx_length;
+    /* invoke callback */
+    if (device->rx_indicate != RT_NULL)
+    {
+        rt_size_t rx_length;
 
-		/* get rx length */
-		rx_length = uart->int_rx->read_index > uart->int_rx->save_index ?
-			UART_RX_BUFFER_SIZE - uart->int_rx->read_index + uart->int_rx->save_index :
-			uart->int_rx->save_index - uart->int_rx->read_index;
+        /* get rx length */
+        rx_length = uart->int_rx->read_index > uart->int_rx->save_index ?
+            UART_RX_BUFFER_SIZE - uart->int_rx->read_index + uart->int_rx->save_index :
+            uart->int_rx->save_index - uart->int_rx->read_index;
 
-		device->rx_indicate(device, rx_length);
-	}
+        device->rx_indicate(device, rx_length);
+    }
 }
 
 /*@}*/
diff --git a/libcpu/unicore32/sep6200/serial.h b/libcpu/unicore32/sep6200/serial.h
index beeceb6165..dcfdc517d4 100644
--- a/libcpu/unicore32/sep6200/serial.h
+++ b/libcpu/unicore32/sep6200/serial.h
@@ -16,73 +16,73 @@
 
 #include <sep6200.h>
 
-#define	USTAT_RCV_READY		0x01   	/* receive data ready */
-#define USTAT_OVERRUN		0x02	/* overrun */
-#define USTAT_PARITY_ERR	0x04	/* parity error */
-#define USTAT_FRAME_ERROR	0x08	/* frame error */
-#define USTAT_BREAK		0x10	/* break */
-#define	USTAT_TXB_EMPTY		0x40   	/* tx buffer empty */
-#define USTAT_RCV_ERR		0x80	/* receive error */
+#define USTAT_RCV_READY     0x01    /* receive data ready */
+#define USTAT_OVERRUN       0x02    /* overrun */
+#define USTAT_PARITY_ERR    0x04    /* parity error */
+#define USTAT_FRAME_ERROR   0x08    /* frame error */
+#define USTAT_BREAK     0x10    /* break */
+#define USTAT_TXB_EMPTY     0x40    /* tx buffer empty */
+#define USTAT_RCV_ERR       0x80    /* receive error */
 
-#define BPS					115200	/* serial baudrate */
+#define BPS                 115200  /* serial baudrate */
 
-#define UART_RX_BUFFER_SIZE		64
-#define UART_TX_BUFFER_SIZE		64
+#define UART_RX_BUFFER_SIZE     64
+#define UART_TX_BUFFER_SIZE     64
 
 /*For sep6200's uart have several secondary function*/
 /*we use union to decribe it*/
 
 union dlbl_fifo
 {
-	rt_uint32_t dlbl;
-	rt_uint32_t rxfifo;
-	rt_uint32_t txfifo;
+    rt_uint32_t dlbl;
+    rt_uint32_t rxfifo;
+    rt_uint32_t txfifo;
 };
 
 union dlbh_ier
 {
-	rt_uint32_t dlbh;
-	rt_uint32_t ier;
+    rt_uint32_t dlbh;
+    rt_uint32_t ier;
 };
 
 union iir_fcr
 {
-	rt_uint32_t iir;
-	rt_uint32_t fcr;
+    rt_uint32_t iir;
+    rt_uint32_t fcr;
 };
 
 struct serial_int_rx
 {
-	rt_uint8_t  rx_buffer[UART_RX_BUFFER_SIZE];
-	rt_uint32_t read_index, save_index;
+    rt_uint8_t  rx_buffer[UART_RX_BUFFER_SIZE];
+    rt_uint32_t read_index, save_index;
 };
 
 struct serial_int_tx
 {
-	rt_uint8_t  tx_buffer[UART_TX_BUFFER_SIZE];
-	rt_uint32_t write_index, save_index;
+    rt_uint8_t  tx_buffer[UART_TX_BUFFER_SIZE];
+    rt_uint32_t write_index, save_index;
 };
 
 typedef struct uartport
 {
-	union dlbl_fifo dlbl_fifo;
-	union dlbh_ier	dlbh_ier;
-	union iir_fcr	iir_fcr;
-	rt_uint32_t lcr;
-	rt_uint32_t mcr;
-	rt_uint32_t lsr;
-	rt_uint32_t msr;
+    union dlbl_fifo dlbl_fifo;
+    union dlbh_ier  dlbh_ier;
+    union iir_fcr   iir_fcr;
+    rt_uint32_t lcr;
+    rt_uint32_t mcr;
+    rt_uint32_t lsr;
+    rt_uint32_t msr;
 }uartport;
 
 struct serial_device
 {
-	uartport* uart_device;
+    uartport* uart_device;
 
-	/* rx structure */
-	struct serial_int_rx* int_rx;
+    /* rx structure */
+    struct serial_int_rx* int_rx;
 
-	/* tx structure */
-	struct serial_int_tx* int_tx;
+    /* tx structure */
+    struct serial_int_tx* int_tx;
 };
 
 rt_err_t rt_hw_serial_register(rt_device_t device, const char* name, rt_uint32_t flag, struct serial_device *serial);
diff --git a/libcpu/unicore32/sep6200/stack.c b/libcpu/unicore32/sep6200/stack.c
index 71b917c214..049b075f6c 100644
--- a/libcpu/unicore32/sep6200/stack.c
+++ b/libcpu/unicore32/sep6200/stack.c
@@ -28,47 +28,47 @@
  */
 
 rt_uint8_t *rt_hw_stack_init(void *tentry, void *parameter,
-	rt_uint8_t *stack_addr, void *texit)
+    rt_uint8_t *stack_addr, void *texit)
 {
-	rt_uint32_t *stk;
+    rt_uint32_t *stk;
 
-	stk 	 = (rt_uint32_t*)stack_addr;
-	*(stk) 	 = (rt_uint32_t)tentry;			/* entry point */
-	*(--stk) = (rt_uint32_t)texit;			/* lr */
-	*(--stk) = 0;							/* r28 */
-	*(--stk) = 0;							/* r27 */
-	*(--stk) = 0;							/* r26 */
-	*(--stk) = 0;							/* r25 */
-	*(--stk) = 0;							/* r24 */
-	*(--stk) = 0;							/* r23 */
-	*(--stk) = 0;							/* r22 */
-	*(--stk) = 0;							/* r21 */
-	*(--stk) = 0;							/* r20 */
-	*(--stk) = 0;							/* r19 */
-	*(--stk) = 0;							/* r18 */
-	*(--stk) = 0;							/* r17 */
-	*(--stk) = 0;							/* r16 */
-	*(--stk) = 0;							/* r15 */
-	*(--stk) = 0;							/* r14 */
-	*(--stk) = 0;							/* r13 */
-	*(--stk) = 0;							/* r12 */
-	*(--stk) = 0;							/* r11 */
-	*(--stk) = 0;							/* r10 */
-	*(--stk) = 0;							/* r9 */
-	*(--stk) = 0;							/* r8 */
-	*(--stk) = 0;							/* r7 */
-	*(--stk) = 0;							/* r6 */
-	*(--stk) = 0;							/* r5 */
-	*(--stk) = 0;							/* r4 */
-	*(--stk) = 0;							/* r3 */
-	*(--stk) = 0;							/* r2 */
-	*(--stk) = 0;							/* r1 */
-	*(--stk) = (rt_uint32_t)parameter; /* r0 : argument */
-	*(--stk) = Mode_PRIV;					/* asr */
-	*(--stk) = Mode_PRIV;					/* bsr */ /*why both PRIV do not need switch?*/
+    stk      = (rt_uint32_t*)stack_addr;
+    *(stk)   = (rt_uint32_t)tentry;         /* entry point */
+    *(--stk) = (rt_uint32_t)texit;          /* lr */
+    *(--stk) = 0;                           /* r28 */
+    *(--stk) = 0;                           /* r27 */
+    *(--stk) = 0;                           /* r26 */
+    *(--stk) = 0;                           /* r25 */
+    *(--stk) = 0;                           /* r24 */
+    *(--stk) = 0;                           /* r23 */
+    *(--stk) = 0;                           /* r22 */
+    *(--stk) = 0;                           /* r21 */
+    *(--stk) = 0;                           /* r20 */
+    *(--stk) = 0;                           /* r19 */
+    *(--stk) = 0;                           /* r18 */
+    *(--stk) = 0;                           /* r17 */
+    *(--stk) = 0;                           /* r16 */
+    *(--stk) = 0;                           /* r15 */
+    *(--stk) = 0;                           /* r14 */
+    *(--stk) = 0;                           /* r13 */
+    *(--stk) = 0;                           /* r12 */
+    *(--stk) = 0;                           /* r11 */
+    *(--stk) = 0;                           /* r10 */
+    *(--stk) = 0;                           /* r9 */
+    *(--stk) = 0;                           /* r8 */
+    *(--stk) = 0;                           /* r7 */
+    *(--stk) = 0;                           /* r6 */
+    *(--stk) = 0;                           /* r5 */
+    *(--stk) = 0;                           /* r4 */
+    *(--stk) = 0;                           /* r3 */
+    *(--stk) = 0;                           /* r2 */
+    *(--stk) = 0;                           /* r1 */
+    *(--stk) = (rt_uint32_t)parameter; /* r0 : argument */
+    *(--stk) = Mode_PRIV;                   /* asr */
+    *(--stk) = Mode_PRIV;                   /* bsr */ /*why both PRIV do not need switch?*/
 
-	/* return task's current stack address */
-	return (rt_uint8_t *)stk;
+    /* return task's current stack address */
+    return (rt_uint8_t *)stk;
 }
 
 /*@}*/
diff --git a/libcpu/unicore32/sep6200/trap.c b/libcpu/unicore32/sep6200/trap.c
index b7d564aa57..f2f342cfbe 100644
--- a/libcpu/unicore32/sep6200/trap.c
+++ b/libcpu/unicore32/sep6200/trap.c
@@ -28,16 +28,16 @@ extern struct rt_thread *rt_current_thread;
 
 void rt_hw_show_register (struct rt_hw_register *regs)
 {
-	rt_kprintf("Execption:\n");
-	rt_kprintf("r00:0x%08x r01:0x%08x r02:0x%08x r03:0x%08x\n", regs->r0, regs->r1, regs->r2, regs->r3);
-	rt_kprintf("r04:0x%08x r05:0x%08x r06:0x%08x r07:0x%08x\n", regs->r4, regs->r5, regs->r6, regs->r7);
-	rt_kprintf("r08:0x%08x r09:0x%08x r10:0x%08x r11:0x%08x\n", regs->r8, regs->r9, regs->r10,regs->r11);
-	rt_kprintf("r12:0x%08x r13:0x%08x r14:0x%08x r15:0x%08x\n", regs->r12,regs->r13,regs->r14,regs->r15);
-	rt_kprintf("r16:0x%08x r17:0x%08x r18:0x%08x r19:0x%08x\n", regs->r16,regs->r17,regs->r18,regs->r19);
-	rt_kprintf("r20:0x%08x r21:0x%08x r22:0x%08x r23:0x%08x\n", regs->r20,regs->r21,regs->r22,regs->r23);
-	rt_kprintf("r24:0x%08x sb:0x%08x  sl:0x%08xfp :0x%08x ip :0x%08x\n",regs->r24,regs->sb,regs->sl,regs->fp,regs->ip);
-	rt_kprintf("sp :0x%08x lr :0x%08x pc :0x%08x\n", regs->sp, regs->lr, regs->pc);
-	rt_kprintf("asr:0x%08x bsr:0x%08x\n", regs->asr,regs->bsr);
+    rt_kprintf("Execption:\n");
+    rt_kprintf("r00:0x%08x r01:0x%08x r02:0x%08x r03:0x%08x\n", regs->r0, regs->r1, regs->r2, regs->r3);
+    rt_kprintf("r04:0x%08x r05:0x%08x r06:0x%08x r07:0x%08x\n", regs->r4, regs->r5, regs->r6, regs->r7);
+    rt_kprintf("r08:0x%08x r09:0x%08x r10:0x%08x r11:0x%08x\n", regs->r8, regs->r9, regs->r10,regs->r11);
+    rt_kprintf("r12:0x%08x r13:0x%08x r14:0x%08x r15:0x%08x\n", regs->r12,regs->r13,regs->r14,regs->r15);
+    rt_kprintf("r16:0x%08x r17:0x%08x r18:0x%08x r19:0x%08x\n", regs->r16,regs->r17,regs->r18,regs->r19);
+    rt_kprintf("r20:0x%08x r21:0x%08x r22:0x%08x r23:0x%08x\n", regs->r20,regs->r21,regs->r22,regs->r23);
+    rt_kprintf("r24:0x%08x sb:0x%08x  sl:0x%08xfp :0x%08x ip :0x%08x\n",regs->r24,regs->sb,regs->sl,regs->fp,regs->ip);
+    rt_kprintf("sp :0x%08x lr :0x%08x pc :0x%08x\n", regs->sp, regs->lr, regs->pc);
+    rt_kprintf("asr:0x%08x bsr:0x%08x\n", regs->asr,regs->bsr);
 }
 
 /**
@@ -50,13 +50,13 @@ void rt_hw_show_register (struct rt_hw_register *regs)
  */
 void rt_hw_trap_extn(struct rt_hw_register *regs)
 {
-	rt_hw_show_register(regs);
+    rt_hw_show_register(regs);
 
-	rt_kprintf("extn instruction\n");
-	rt_kprintf("thread - %s stack:\n", rt_current_thread->name);
-	rt_hw_backtrace((rt_uint32_t *)regs->fp, (rt_uint32_t)rt_current_thread->entry);
+    rt_kprintf("extn instruction\n");
+    rt_kprintf("thread - %s stack:\n", rt_current_thread->name);
+    rt_hw_backtrace((rt_uint32_t *)regs->fp, (rt_uint32_t)rt_current_thread->entry);
 
-	rt_hw_cpu_shutdown();
+    rt_hw_cpu_shutdown();
 }
 
 /**
@@ -70,10 +70,10 @@ void rt_hw_trap_extn(struct rt_hw_register *regs)
  */
 void rt_hw_trap_swi(struct rt_hw_register *regs)
 {
-	rt_hw_show_register(regs);
+    rt_hw_show_register(regs);
 
-	rt_kprintf("software interrupt\n");
-	rt_hw_cpu_shutdown();
+    rt_kprintf("software interrupt\n");
+    rt_hw_cpu_shutdown();
 }
 
 /**
@@ -86,13 +86,13 @@ void rt_hw_trap_swi(struct rt_hw_register *regs)
  */
 void rt_hw_trap_pabt(struct rt_hw_register *regs)
 {
-	rt_hw_show_register(regs);
+    rt_hw_show_register(regs);
 
-	rt_kprintf("prefetch abort\n");
-	rt_kprintf("thread - %s stack:\n", rt_current_thread->name);
-	rt_hw_backtrace((rt_uint32_t *)regs->fp, (rt_uint32_t)rt_current_thread->entry);
+    rt_kprintf("prefetch abort\n");
+    rt_kprintf("thread - %s stack:\n", rt_current_thread->name);
+    rt_hw_backtrace((rt_uint32_t *)regs->fp, (rt_uint32_t)rt_current_thread->entry);
 
-	rt_hw_cpu_shutdown();
+    rt_hw_cpu_shutdown();
 }
 
 /**
@@ -105,13 +105,13 @@ void rt_hw_trap_pabt(struct rt_hw_register *regs)
  */
 void rt_hw_trap_dabt(struct rt_hw_register *regs)
 {
-	rt_hw_show_register(regs);
+    rt_hw_show_register(regs);
 
-	rt_kprintf("data abort\n");
-	rt_kprintf("thread - %s stack:\n", rt_current_thread->name);
-	rt_hw_backtrace((rt_uint32_t *)regs->fp, (rt_uint32_t)rt_current_thread->entry);
+    rt_kprintf("data abort\n");
+    rt_kprintf("thread - %s stack:\n", rt_current_thread->name);
+    rt_hw_backtrace((rt_uint32_t *)regs->fp, (rt_uint32_t)rt_current_thread->entry);
 
-	rt_hw_cpu_shutdown();
+    rt_hw_cpu_shutdown();
 }
 
 /**
@@ -123,9 +123,9 @@ void rt_hw_trap_dabt(struct rt_hw_register *regs)
  */
 void rt_hw_trap_resv(struct rt_hw_register *regs)
 {
-	rt_kprintf("not used\n");
-	rt_hw_show_register(regs);
-	rt_hw_cpu_shutdown();
+    rt_kprintf("not used\n");
+    rt_hw_show_register(regs);
+    rt_hw_cpu_shutdown();
 }
 
 extern struct rt_irq_desc isr_table[];
@@ -138,7 +138,7 @@ void rt_hw_trap_irq(void)
   void *param;
 
   /* get the interrupt number */
-	irq = *(RP)(SEP6200_VIC_IRQ_VECTOR_NUM);
+    irq = *(RP)(SEP6200_VIC_IRQ_VECTOR_NUM);
 
   /* get interrupt service routine */
   isr_func = isr_table[irq].handler;
@@ -148,13 +148,13 @@ void rt_hw_trap_irq(void)
   isr_func(irq, param);
 
 #ifdef RT_USING_INTERRUPT_INFO
-	isr_table[irq].counter++;
+    isr_table[irq].counter++;
 #endif /* RT_USING_INTERRUPT_INFO */
 }
 
 void rt_hw_trap_fiq()
 {
-	rt_kprintf("fast interrupt request\n");
+    rt_kprintf("fast interrupt request\n");
 }
 
 /*@}*/