for rt-thread 1.1.0

git-svn-id: https://rt-thread.googlecode.com/svn/trunk@2372 bbd45198-f89e-11dd-88c7-29a3b14d5316

bsp/microblaze/board.c

@@ -11,7 +11,7 @@
  * Date           Author       Notes
  * 2006-08-23     Bernard      first implementation
  *
- * 2011-12-17     nl1031       for MicroBlaze
+ * 2011-12-17     nl1031       for MacroBlaze
  *
  */
 
@@ -48,6 +48,9 @@ XGpio gpio_output; /* The driver instance for GPIO Device configured as O/P */
 XUartLite 	uart_lite; 		/* Instance of the UartLite device */
 XIntc 		int_ctl; 		/* The instance of the Interrupt Controller */
 static		rt_uint32_t led_data;
+static int cnt;
+
+
 
 static void rt_hw_board_led_init(void);
 
@@ -58,6 +61,7 @@ static void rt_hw_board_led_init()
 {
 	rt_uint32_t status;
 	led_data = 0;
+	cnt = 0;
 	status = XGpio_Initialize(&gpio_output, LEDS_DEVICE_ID);
 	if (status != XST_SUCCESS)
 	{
@@ -96,17 +100,19 @@ void rt_hw_board_led_off(rt_uint32_t led)
 	XGpio_DiscreteWrite(&gpio_output, 1, led_data);
 }
 
+
 void rt_hw_led_flash(void)
 {
-    rt_uint32_t i;
+	volatile rt_uint32_t i;
 
 	rt_hw_board_led_off(1);
-    for (i = 0; i < 20000; i++) ;
+	for (i = 0; i < 20000; i ++);
 
 	rt_hw_board_led_on(1);
-    for (i = 0; i < 20000; i++) ;
+	for (i = 0; i < 20000; i ++);
 }
 
+
 #ifdef RT_USING_CONSOLE
 
 /*
@@ -124,6 +130,7 @@ void rt_hw_console_output(const char* str)
 	{
 
 		/* Transmit Character */
+
 		XUartLite_SendByte(STDOUT_BASEADDRESS, *str);
 		if (*str == '\n')
 			XUartLite_SendByte(STDOUT_BASEADDRESS, '\r');
@@ -147,6 +154,7 @@ static void rt_hw_console_init()
 }
 #endif
 
+
 void rt_hw_timer_handler(void)
 {
 	rt_uint32_t csr;
@@ -157,26 +165,26 @@ void rt_hw_timer_handler(void)
 	if (csr & XTC_CSR_INT_OCCURED_MASK)
 	{
 		rt_tick_increase();
-
 		XTmrCtr_WriteReg(timer.BaseAddress, TIMER_CNTR_0, XTC_TCSR_OFFSET, csr | XTC_CSR_INT_OCCURED_MASK);
 	}
 
 }
 
-/*
- *********************************************************************************************************
- *                                           rt_intc_init()
- *
- * Description: This function intializes the interrupt controller by registering the appropriate handler
- *              functions and enabling interrupts.
- *
- * Arguments  : None
- *
- * Returns    : None
- *********************************************************************************************************
- */
 
-void rt_intc_init(void)
+/*
+*********************************************************************************************************
+*                                           rt_intc_init()
+*
+* Description: This function intializes the interrupt controller by registering the appropriate handler
+*              functions and enabling interrupts.
+*
+* Arguments  : None
+*
+* Returns    : None
+*********************************************************************************************************
+*/
+
+void  rt_intc_init (void)
 {
     XStatus  status;
 
@@ -185,32 +193,34 @@ void rt_intc_init(void)
     status = XIntc_Initialize(&int_ctl, XPAR_INTC_0_DEVICE_ID);
 
 	/* install interrupt handler */
-    rt_hw_interrupt_install(XPAR_INTC_0_TMRCTR_0_VEC_ID, (rt_isr_handler_t) rt_hw_timer_handler, RT_NULL);
-
+    rt_hw_interrupt_install(XPAR_INTC_0_TMRCTR_0_VEC_ID, (rt_isr_handler_t)rt_hw_timer_handler, RT_NULL);
 	rt_hw_interrupt_umask(XPAR_INTC_0_TMRCTR_0_VEC_ID);
 
 	XIntc_Start(&int_ctl, XIN_REAL_MODE);
 
 }
 
-void rt_tmr_init(void)
+
+void  rt_tmr_init (void)
 {
 	rt_uint32_t ctl;
     XStatus  	status;
 
-    status = XTmrCtr_Initialize(&timer, XPAR_AXI_TIMER_0_DEVICE_ID);
-
+    status = XTmrCtr_Initialize(&timer,XPAR_AXI_TIMER_0_DEVICE_ID);
 	XTmrCtr_WriteReg(timer.BaseAddress, TIMER_CNTR_0, XTC_TLR_OFFSET, PIV);
-
     ctl = XTC_CSR_ENABLE_TMR_MASK | XTC_CSR_ENABLE_INT_MASK | XTC_CSR_AUTO_RELOAD_MASK | XTC_CSR_DOWN_COUNT_MASK;
 	XTmrCtr_WriteReg(timer.BaseAddress, TIMER_CNTR_0, XTC_TCSR_OFFSET, ctl);
 }
 
+
+
 /**
  * This function will initial SPARTAN 6 LX9 board.
  */
 void rt_hw_board_init()
 {
+	microblaze_disable_icache();
+	microblaze_disable_dcache();
 	/* init hardware console */
 	rt_hw_console_init();
 
@@ -223,4 +233,5 @@ void rt_hw_board_init()
     /* timer init */
     rt_tmr_init();
 
+
 }

bsp/microblaze/board.h

@@ -13,6 +13,7 @@
 #define __BOARD_H__
 
 
+#define MCK		50000000
 
 void rt_hw_board_led_on(rt_uint32_t);
 void rt_hw_board_led_off(rt_uint32_t);

bsp/microblaze/rtconfig.h

@@ -16,6 +16,7 @@
 /* Tick per Second*/
 #define RT_TICK_PER_SECOND	100
 
+
 /* SECTION: RT_DEBUG */
 /* Thread Debug*/
 /* #define RT_THREAD_DEBUG */
@@ -88,6 +89,7 @@
 #define FINSH_THREAD_STACK_SIZE 8192
 #define RT_USING_TC
 
+
 /* SECTION: a runtime libc library */
 /* a runtime libc library*/
 /* #define RT_USING_NEWLIB */

bsp/microblaze/startup.c

@@ -25,6 +25,7 @@ extern void finsh_system_init(void);
 
 extern void rt_hw_led_flash(void);
 
+
 /*@{*/
 #ifdef __CC_ARM
 extern int Image$$RW_IRAM1$$ZI$$Limit;
@@ -69,7 +70,8 @@ void rtthread_startup(void)
 #elif __ICCARM__
     rt_system_heap_init(__segment_end("HEAP"), (void*)0x204000);
 #else
-    rt_system_heap_init((void*) &__bss_end, (void*) (&__bss_end + 0x4000));
+	rt_system_heap_init((void*)&__bss_end, (void*)(&__bss_end+0x4000));
+
 #endif
 #endif
 
@@ -104,10 +106,10 @@ void rtthread_startup(void)
 	rt_system_scheduler_start();
 
 	/* never reach here */
-    return;
+	return ;
 }
 
-int main(void)
+int main (void)
 {
 	/* invoke rtthread_startup */
 	rtthread_startup();

examples/kernel/thread_delete.c

@@ -131,7 +131,7 @@ int _tc_thread_delete()
 	tc_cleanup(_tc_cleanup);
 	thread_delete_init();
 
-	return 25;
+	return 27;
 }
 FINSH_FUNCTION_EXPORT(_tc_thread_delete, a thread delete example);
 #else

examples/kernel/thread_same_priority.c

@@ -6,8 +6,8 @@ static struct rt_thread thread2;
 static char thread1_stack[THREAD_STACK_SIZE];
 static char thread2_stack[THREAD_STACK_SIZE];
 
-static rt_uint32_t t1_count = 0;
-static rt_uint32_t t2_count = 0;
+volatile static rt_uint32_t t1_count = 0;
+volatile static rt_uint32_t t2_count = 0;
 static void thread1_entry(void* parameter)
 {
 	while (1)
@@ -65,8 +65,12 @@ static void _tc_cleanup()
 	/* unlock scheduler */
 	rt_exit_critical();
 
+	rt_kprintf("t1_count=%d t2_count=%d\n",t1_count,t2_count);
+
 	if (t1_count / t2_count != 2)
 		tc_stat(TC_STAT_END | TC_STAT_FAILED);
+	else
+		tc_done(TC_STAT_PASSED);
 }
 
 int _tc_thread_same_priority()

libcpu/xilinx/microblaze/context_gcc.S

@@ -44,7 +44,6 @@ rt_hw_interrupt_disable:
 
     	RTSD    r15, 8
     	AND     r0, r0, r0
-
 	.end	rt_hw_interrupt_disable
 
 /*
@@ -57,7 +56,6 @@ rt_hw_interrupt_disable:
 rt_hw_interrupt_enable:
     	RTSD    r15, 8
     	MTS     rMSR, r5               		/* Move the saved status from r5 into rMSR            */
-	
 	.end	rt_hw_interrupt_enable
 
 /*
@@ -83,7 +81,7 @@ rt_hw_context_switch:
     	BNEI    r3,  rt_hw_context_switch_ie /*if IE bit set,should be use RTID (return from interrupt). */
 
     	LWI     r3,  r1, STACK_RMSR
-    MTS     RMSR,  r3
+    	MTS     RMSR,r3
 	POP_ALL
     	ADDIK   r1,  r1, STACK_SIZE
     	RTSD    r15, 8
@@ -93,13 +91,12 @@ rt_hw_context_switch_ie:
 
     	LWI     r3,  r1, STACK_RMSR
     	ANDNI   r3,  r3, IE_BIT         	/* clear IE bit, prevent interrupt occur immediately*/
-    MTS     RMSR,  r3
+    	MTS     RMSR,r3
     	LWI     r3,  r1, STACK_R03
 	POP_ALL
     	ADDIK   r1,  r1, STACK_SIZE
     	RTID    r14, 0                    	/* IE bit will be set automatically */
     	AND     r0,  r0, r0
-  
 	.end	rt_hw_context_switch
 
 /*
@@ -113,7 +110,7 @@ rt_hw_context_switch_to:
 	LWI		r1,	 r5, 0 					/* get new task stack pointer */
     	LWI     r3,  r1, STACK_RMSR
     	ANDNI   r3,  r3, IE_BIT         	/* clear IE bit, prevent interrupt occur immediately*/
-    MTS     RMSR,  r3
+    	MTS     RMSR,r3
 	POP_ALL
     	ADDIK   r1,  r1, STACK_SIZE
     	RTID    r14, 0                    	/* IE bit will be set automatically */
@@ -141,15 +138,15 @@ rt_hw_context_switch_interrupt:
 	LA	r3, r0, rt_interrupt_from_thread /* set rt_interrupt_from_thread */
 	SWI	r5, r3, 0 					/* rt_interrupt_from_thread = from */
 _reswitch:
-    LA	    r3,    r0,    rt_interrupt_to_thread/* set rt_interrupt_to_thread */
+	LA	r3, r0, rt_interrupt_to_thread	/* set rt_interrupt_to_thread */
 	SWI	r6, r3, 0 					/* rt_interrupt_to_thread = to */
     	RTSD    r15, 8
     	AND     r0, r0, r0
-	
 	.end rt_hw_context_switch_interrupt
 
 
     .globl     	_interrupt_handler
+	.section .text
 	.align 	2
 	.ent _interrupt_handler
 	.type _interrupt_handler, @function
@@ -169,7 +166,7 @@ _interrupt_handler:
     	BRLID   r15, rt_interrupt_leave
     	AND     r0,  r0, r0
 
-/*
+	/*
 	 * if rt_thread_switch_interrupt_flag set, jump to
 	 * rt_hw_context_switch_interrupt_do and don't return
 	 */
@@ -181,7 +178,7 @@ _interrupt_handler:
 
     	LWI     r3,  r1, STACK_RMSR
     	ANDNI   r3,  r3, IE_BIT
-    MTS     RMSR,  r3
+    	MTS     RMSR,r3
 	POP_ALL
     	ADDIK   r1,  r1, STACK_SIZE
 
@@ -207,7 +204,7 @@ rt_hw_context_switch_interrupt_do:
     	BNEI    r3,  return_with_ie     	/*if IE bit set,should be use RTID (return from interrupt). */
 
     	LWI     r3,  r1, STACK_RMSR
-    MTS     RMSR,  r3
+    	MTS     RMSR,r3
 	POP_ALL
     	ADDIK   r1,  r1, STACK_SIZE
     	RTSD    r15, 8
@@ -217,12 +214,12 @@ return_with_ie:
 
     	LWI     r3,  r1, STACK_RMSR
     	ANDNI   r3,  r3, IE_BIT         	/* clear IE bit, prevent interrupt occur immediately*/
-    MTS     RMSR,  r3
+    	MTS     RMSR,r3
     	LWI     r3,  r1, STACK_R03
 	POP_ALL
     	ADDIK   r1,  r1, STACK_SIZE
     	RTID    r14, 0                    	/* IE bit will be set automatically */
     	AND     r0,  r0, r0
 
-    .end    _interrupt_handler
+.end _interrupt_handler
 

libcpu/xilinx/microblaze/serial.c

@@ -58,7 +58,7 @@ static void rt_hw_serial_isr(void)
 	RT_ASSERT(serial != RT_NULL);
 
 	/* get generic device object */
-    device = (rt_device_t) serial;
+	device = (rt_device_t)serial;
 
 	/* disable interrupt */
 	level = rt_hw_interrupt_disable();
@@ -71,14 +71,14 @@ static void rt_hw_serial_isr(void)
 		serial->rx_buffer[serial->save_index] = serial->hw_base->Rx_FIFO;
 
 		/* move to next position */
-        serial->save_index++;
+		serial->save_index ++;
 		if (serial->save_index >= RT_UART_RX_BUFFER_SIZE)
 			serial->save_index = 0;
 
 		/* if the next position is read index, discard this 'read char' */
 		if (serial->save_index == serial->read_index)
 		{
-            serial->read_index++;
+			serial->read_index ++;
 			if (serial->read_index >= RT_UART_RX_BUFFER_SIZE)
 				serial->read_index = 0;
 		}
@@ -93,13 +93,14 @@ static void rt_hw_serial_isr(void)
 
 }
 
-static rt_err_t rt_serial_init(rt_device_t dev)
+static rt_err_t rt_serial_init (rt_device_t dev)
 {
 	struct rt_mb_uart_lite* serial = (struct rt_mb_uart_lite*) dev;
 
 	RT_ASSERT(serial != RT_NULL);
 
-    RT_ASSERT(serial->peripheral_id != XPAR_INTC_0_UARTLITE_1_VEC_ID);
+	RT_ASSERT(serial->peripheral_id != XPAR_UARTLITE_1_DEVICE_ID);
+
 
 	/* reset rx index */
 	serial->save_index = 0;
@@ -113,7 +114,7 @@ static rt_err_t rt_serial_init(rt_device_t dev)
 
 static rt_err_t rt_serial_open(rt_device_t dev, rt_uint16_t oflag)
 {
-    struct rt_mb_uart_lite *serial = (struct rt_mb_uart_lite*) dev;
+	struct rt_mb_uart_lite *serial = (struct rt_mb_uart_lite*)dev;
 	RT_ASSERT(serial != RT_NULL);
 
 	if (dev->flag & RT_DEVICE_FLAG_INT_RX)
@@ -122,7 +123,7 @@ static rt_err_t rt_serial_open(rt_device_t dev, rt_uint16_t oflag)
 		serial->hw_base->CTRL_REG = XUL_CR_ENABLE_INTR; 		/* enable interrupt */
 
 		/* install UART handler */
-        rt_hw_interrupt_install(serial->peripheral_id, (rt_isr_handler_t) rt_hw_serial_isr, RT_NULL);
+		rt_hw_interrupt_install(serial->peripheral_id, (rt_isr_handler_t)rt_hw_serial_isr, RT_NULL);
 		rt_hw_interrupt_umask(serial->peripheral_id);
 	}
 
@@ -131,7 +132,7 @@ static rt_err_t rt_serial_open(rt_device_t dev, rt_uint16_t oflag)
 
 static rt_err_t rt_serial_close(rt_device_t dev)
 {
-    struct rt_mb_uart_lite *serial = (struct rt_mb_uart_lite*) dev;
+	struct rt_mb_uart_lite *serial = (struct rt_mb_uart_lite*)dev;
 	RT_ASSERT(serial != RT_NULL);
 
 	if (dev->flag & RT_DEVICE_FLAG_INT_RX)
@@ -143,10 +144,10 @@ static rt_err_t rt_serial_close(rt_device_t dev)
 	return RT_EOK;
 }
 
-static rt_size_t rt_serial_read(rt_device_t dev, rt_off_t pos, void* buffer, rt_size_t size)
+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;
-    struct rt_mb_uart_lite *serial = (struct rt_mb_uart_lite*) dev;
+	struct rt_mb_uart_lite *serial = (struct rt_mb_uart_lite*)dev;
 	RT_ASSERT(serial != RT_NULL);
 
 	/* point to buffer */
@@ -165,10 +166,11 @@ static rt_size_t rt_serial_read(rt_device_t dev, rt_off_t pos, void* buffer, rt_
 			{
 				*ptr = serial->rx_buffer[serial->read_index];
 
-                serial->read_index++;
+				serial->read_index ++;
 				if (serial->read_index >= RT_UART_RX_BUFFER_SIZE)
 					serial->read_index = 0;
-            } else
+			}
+			else
 			{
 				/* no data in rx buffer */
 
@@ -180,40 +182,40 @@ static rt_size_t rt_serial_read(rt_device_t dev, rt_off_t pos, void* buffer, rt_
 			/* enable interrupt */
 			rt_hw_interrupt_enable(level);
 
-            ptr++;
-            size--;
+			ptr ++; size --;
 		}
 
-        return (rt_uint32_t) ptr - (rt_uint32_t) buffer;
-    } else if (dev->flag & RT_DEVICE_FLAG_DMA_RX)
+		return (rt_uint32_t)ptr - (rt_uint32_t)buffer;
+	}
+	else if (dev->flag & RT_DEVICE_FLAG_DMA_RX)
 	{
 		/* not support right now */
 		RT_ASSERT(0);
-    } else
+	}
+	else
 	{
 		/* poll mode */
 		while (size)
 		{
 			/* Wait for Full Rx Buffer */
-            while (!(serial->hw_base->STAT_REG & XUL_SR_RX_FIFO_VALID_DATA))
-                ;
+			while (!(serial->hw_base->STAT_REG & XUL_SR_RX_FIFO_VALID_DATA));
 
 			/* Read Character */
 			*ptr = serial->hw_base->Rx_FIFO;
-            ptr++;
-            size--;
+			ptr ++;
+			size --;
 		}
 
-        return (rt_size_t) ptr - (rt_size_t) buffer;
+		return (rt_size_t)ptr - (rt_size_t)buffer;
 	}
 
 	return 0;
 }
 
-static rt_size_t rt_serial_write(rt_device_t dev, rt_off_t pos, const void* buffer, rt_size_t size)
+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;
-    struct rt_mb_uart_lite *serial = (struct rt_mb_uart_lite*) dev;
+	struct rt_mb_uart_lite *serial = (struct rt_mb_uart_lite*)dev;
 	RT_ASSERT(serial != RT_NULL);
 
 	ptr = (rt_uint8_t*) buffer;
@@ -227,18 +229,20 @@ static rt_size_t rt_serial_write(rt_device_t dev, rt_off_t pos, const void* buff
 				/* stream mode */
 				if (*ptr == '\n')
 				{
-                    while (!(serial->hw_base->STAT_REG & XUL_SR_TX_FIFO_EMPTY))
-                        ;
+					while (!(serial->hw_base->STAT_REG & XUL_SR_TX_FIFO_EMPTY));
 					serial->hw_base->Tx_FIFO = '\r';
 				}
 
 				/* Wait for Empty Tx Buffer */
-                while (!(serial->hw_base->STAT_REG & XUL_SR_TX_FIFO_EMPTY)) ;
+				while (!(serial->hw_base->STAT_REG & XUL_SR_TX_FIFO_EMPTY));
 
 				/* Transmit Character */
 				serial->hw_base->Tx_FIFO = *ptr;
-                ptr++;
-                size--;
+				if (*ptr & 1)
+					rt_hw_board_led_on(2);
+				else
+					rt_hw_board_led_off(2);
+				ptr ++; size --;
 			}
 		}
 		else
@@ -246,21 +250,23 @@ static rt_size_t rt_serial_write(rt_device_t dev, rt_off_t pos, const void* buff
 			while (size)
 			{
 				/* Wait for Empty Tx Buffer */
-                while (!(serial->hw_base->STAT_REG & XUL_SR_TX_FIFO_EMPTY))
-                    ;
+				while (!(serial->hw_base->STAT_REG & XUL_SR_TX_FIFO_EMPTY));
 
 				/* Transmit Character */
 				serial->hw_base->Tx_FIFO = *ptr;
-                ptr++;
-                size--;
+				if (*ptr & 1)
+					rt_hw_board_led_on(2);
+				else
+					rt_hw_board_led_off(2);
+				ptr ++; size --;
 			}
 		}
 	}
 
-    return (rt_size_t) ptr - (rt_size_t) buffer;
+	return (rt_size_t)ptr - (rt_size_t)buffer;
 }
 
-static rt_err_t rt_serial_control(rt_device_t dev, rt_uint8_t cmd, void *args)
+static rt_err_t rt_serial_control (rt_device_t dev, rt_uint8_t cmd, void *args)
 {
 	return RT_EOK;
 }
@@ -287,9 +293,9 @@ rt_err_t rt_hw_serial_init()
 	device = (rt_device_t) &serial1;
 
 	/* init serial device private data */
-    serial1.hw_base = (struct rt_mb_uart_lite_hw*) XPAR_USB_UART_BASEADDR;
-    serial1.peripheral_id = XPAR_INTC_0_UARTLITE_1_VEC_ID;
-    serial1.baudrate = 9600;
+	serial1.hw_base 		= (struct rt_mb_uart_lite_hw*)XPAR_USB_UART_BASEADDR;
+	serial1.peripheral_id 	= XPAR_UARTLITE_1_DEVICE_ID;
+	serial1.baudrate		= 115200;
 
 	/* set device virtual interface */
 	device->init 	= rt_serial_init;
@@ -303,6 +309,8 @@ rt_err_t rt_hw_serial_init()
 	rt_device_register(device, "uart1", RT_DEVICE_FLAG_RDWR | RT_DEVICE_FLAG_INT_RX);
 #endif
 
+
 	return RT_EOK;
 }
 
+

libcpu/xilinx/microblaze/stack.c

@@ -16,6 +16,8 @@
 extern   void  *_SDA_BASE_;
 extern   void  *_SDA2_BASE_;
 
+
+
 /**
  * This function will initialize thread stack
  *
@@ -26,11 +28,12 @@ extern void *_SDA2_BASE_;
  *
  * @return stack address
  */
-rt_uint8_t *rt_hw_stack_init(void *tentry, void *parameter, rt_uint8_t *stack_addr, void *texit)
+rt_uint8_t *rt_hw_stack_init(void *tentry, void *parameter,
+	rt_uint8_t *stack_addr, void *texit)
 {
 	unsigned long *stk;
 
-    stk = (unsigned long *) stack_addr;
+	stk 	 = (unsigned long *)stack_addr;
 	stk--;
 	stk--;
 	*stk-- = 0;								/* r31 */
@@ -48,9 +51,9 @@ rt_uint8_t *rt_hw_stack_init(void *tentry, void *parameter, rt_uint8_t *stack_ad
 	*stk-- = 0;								/* r19 */
 	*stk-- = 0;								/* r18 */
 	*stk-- = 0;								/* r17 */
-    *stk-- = (unsigned long) texit - 8; /* r15 = task return address*/
-    *stk-- = (unsigned long) tentry; /* r14 = entry address*/
-    *stk-- = (unsigned long) &_SDA_BASE_; /* r13 */
+	*stk-- = (unsigned long)texit - 8;		/* r15 = task return address*/
+	*stk-- = (unsigned long)tentry;		/* r14 = entry address*/
+	*stk-- = (unsigned long)&_SDA_BASE_;	/* r13 */
 	*stk-- = 0;								/* r12 */
 	*stk-- = 0;								/* r11 */
 	*stk-- = 0;								/* r10 */
@@ -61,8 +64,8 @@ rt_uint8_t *rt_hw_stack_init(void *tentry, void *parameter, rt_uint8_t *stack_ad
 	*stk-- = (unsigned long) parameter;	/* r05 */
 	*stk-- = 0;								/* r04 */
 	*stk-- = 0;								/* r03 */
-    *stk-- = (unsigned long) &_SDA2_BASE_; /* r02 */
+	*stk-- = (unsigned long)&_SDA2_BASE_;	/* r02 */
 	*stk   = 2;   							/* enable interrupt */
-    return (rt_uint8_t *) stk;
+	return (rt_uint8_t *)stk;
 }
 

libcpu/xilinx/microblaze/trap.c

@@ -20,14 +20,17 @@
 #include    "xintc_i.h"
 #include    "xintc_l.h"
 
+
 #define MAX_HANDLERS  XPAR_INTC_MAX_NUM_INTR_INPUTS
 extern XIntc int_ctl; /* The instance of the Interrupt Controller */
 
+
 extern rt_uint32_t rt_interrupt_nest;
 
 rt_uint32_t rt_interrupt_from_thread, rt_interrupt_to_thread;
 rt_uint32_t rt_thread_switch_interrupt_flag;
 
+
 void rt_hw_interrupt_handler(int vector)
 {
 	rt_kprintf("Unhandled interrupt %d occured!!!\n", vector);
@@ -42,11 +45,13 @@ void rt_hw_interrupt_init()
 
 	XIntc_Config           *CfgPtr;
 
+
     CfgPtr = &XIntc_ConfigTable[0];
 
-    for (index = 0; index < MAX_HANDLERS; index++)
+
+	for (index = 0; index < MAX_HANDLERS; index ++)
 	{
-        CfgPtr->HandlerTable[index].Handler = (XInterruptHandler) rt_hw_interrupt_handler;
+		CfgPtr->HandlerTable[index].Handler = (XInterruptHandler)rt_hw_interrupt_handler;
 	}
 
 	/* init interrupt nest, and context in thread sp */
@@ -63,7 +68,7 @@ void rt_hw_interrupt_init()
 void rt_hw_interrupt_mask(int vector)
 {
 	/* disable interrupt */
-    XIntc_Disable(&int_ctl, vector);
+	XIntc_Disable(&int_ctl,vector);
 }
 
 /**
@@ -72,7 +77,7 @@ void rt_hw_interrupt_mask(int vector)
  */
 void rt_hw_interrupt_umask(int vector)
 {
-    XIntc_Enable(&int_ctl, vector);
+	XIntc_Enable(&int_ctl,vector);
 }
 
 /**
@@ -87,45 +92,44 @@ void rt_hw_interrupt_install(int vector, rt_isr_handler_t new_handler, rt_isr_ha
 
     CfgPtr = &XIntc_ConfigTable[0];
 
-    if (vector >= 0 && vector < MAX_HANDLERS)
+	if(vector >= 0 && vector < MAX_HANDLERS)
 	{
-        if (*old_handler != RT_NULL)
-            *old_handler = (rt_isr_handler_t) CfgPtr->HandlerTable[vector].Handler;
-        if (new_handler != RT_NULL)
-            CfgPtr->HandlerTable[vector].Handler = (XInterruptHandler) new_handler;
+		if (*old_handler != RT_NULL) *old_handler = (rt_isr_handler_t)CfgPtr->HandlerTable[vector].Handler;
+		if (new_handler != RT_NULL) CfgPtr->HandlerTable[vector].Handler = (XInterruptHandler)new_handler;
 	}
 }
 
 /*****************************************************************************/
 /** copy from XIntc_DeviceInterruptHandler in xintc_l.c nl1031
- *
- * This function is the primary interrupt handler for the driver. It must be
- * connected to the interrupt source such that is called when an interrupt of
- * the interrupt controller is active. It will resolve which interrupts are
- * active and enabled and call the appropriate interrupt handler. It uses
- * the AckBeforeService flag in the configuration data to determine when to
- * acknowledge the interrupt. Highest priority interrupts are serviced first.
- * The driver can be configured to service only the highest priority interrupt
- * or all pending interrupts using the {XIntc_SetOptions()} function or
- * the {XIntc_SetIntrSrvOption()} function.
- *
- * This function assumes that an interrupt vector table has been previously
- * initialized.  It does not verify that entries in the table are valid before
- * calling an interrupt handler.
- *
- *
- * @return	None.
- *
- * @note
- *
- * The constant XPAR_INTC_MAX_NUM_INTR_INPUTS must be setup for this to compile.
- * Interrupt IDs range from 0 - 31 and correspond to the interrupt input signals
- * for the interrupt controller. XPAR_INTC_MAX_NUM_INTR_INPUTS specifies the
- * highest numbered interrupt input signal that is used.
- *
- ******************************************************************************/
-
-void rt_hw_trap_irq(void)
+*
+* This function is the primary interrupt handler for the driver. It must be
+* connected to the interrupt source such that is called when an interrupt of
+* the interrupt controller is active. It will resolve which interrupts are
+* active and enabled and call the appropriate interrupt handler. It uses
+* the AckBeforeService flag in the configuration data to determine when to
+* acknowledge the interrupt. Highest priority interrupts are serviced first.
+* The driver can be configured to service only the highest priority interrupt
+* or all pending interrupts using the {XIntc_SetOptions()} function or
+* the {XIntc_SetIntrSrvOption()} function.
+*
+* This function assumes that an interrupt vector table has been previously
+* initialized.  It does not verify that entries in the table are valid before
+* calling an interrupt handler.
+*
+*
+* @return	None.
+*
+* @note
+*
+* The constant XPAR_INTC_MAX_NUM_INTR_INPUTS must be setup for this to compile.
+* Interrupt IDs range from 0 - 31 and correspond to the interrupt input signals
+* for the interrupt controller. XPAR_INTC_MAX_NUM_INTR_INPUTS specifies the
+* highest numbered interrupt input signal that is used.
+*
+******************************************************************************/
+
+
+void rt_hw_trap_irq(void )
 {
 	u32 intr_status;
 	u32 intr_mask = 1;
@@ -133,6 +137,7 @@ void rt_hw_trap_irq(void)
 	volatile u32 reg;			/* used as bit bucket */
 	XIntc_Config *cfg_ptr;
 
+
 	/* Get the configuration data using the device ID */
 	cfg_ptr = &XIntc_ConfigTable[0];
 
@@ -203,3 +208,4 @@ void rt_hw_trap_irq(void)
 	}
 }
 
+