3 files changed, 219 insertions, 219 deletions

diff --git a/bsp/lm3s9b9x/drivers/board.c b/bsp/lm3s9b9x/drivers/board.c
index 58e820512e..fc79ef4d08 100644
--- a/bsp/lm3s9b9x/drivers/board.c
+++ b/bsp/lm3s9b9x/drivers/board.c
@@ -41,14 +41,14 @@ extern void rt_hw_interrupt_thread_switch(void);
  */
 void rt_hw_timer_handler(void)
 {
-	/* enter interrupt */
-	rt_interrupt_enter();
+    /* enter interrupt */
+    rt_interrupt_enter();
 
-	rt_tick_increase();
+    rt_tick_increase();
 
-	/* leave interrupt */
-	rt_interrupt_leave();
-	rt_hw_interrupt_thread_switch();
+    /* leave interrupt */
+    rt_interrupt_leave();
+    rt_hw_interrupt_thread_switch();
 }
 
 /**
@@ -76,52 +76,52 @@ void rt_hw_eth_handler(void)
  */
 void rt_hw_board_init()
 {
-	// set sysclock to 80M
+    // set sysclock to 80M
     SysCtlClockSet(SYSCTL_SYSDIV_2_5 | SYSCTL_USE_PLL | SYSCTL_OSC_MAIN | SYSCTL_XTAL_16MHZ);
 
-	/* init systick */
-	SysTickDisable();
-	SysTickPeriodSet(SysCtlClockGet()/RT_TICK_PER_SECOND);
-	SysTickIntEnable();
-	SysTickEnable();
+    /* init systick */
+    SysTickDisable();
+    SysTickPeriodSet(SysCtlClockGet()/RT_TICK_PER_SECOND);
+    SysTickIntEnable();
+    SysTickEnable();
 
-	/* enable ssio */
-	//SysCtlPeripheralEnable(SYSCTL_PERIPH_SSI0);
+    /* enable ssio */
+    //SysCtlPeripheralEnable(SYSCTL_PERIPH_SSI0);
 
 #if LM3S_EXT_SRAM == 1
-	/* init SDRAM */
-	rt_hw_sdram_init();
+    /* init SDRAM */
+    rt_hw_sdram_init();
 #endif
-	/* init console */
-	rt_hw_console_init();
+    /* init console */
+    rt_hw_console_init();
 
-	/* enable interrupt */
-	IntMasterEnable();
+    /* enable interrupt */
+    IntMasterEnable();
 }
 
 /* init console to support rt_kprintf */
 static void rt_hw_console_init()
 {
-	/* Enable the UART0 peripherals */
-	SysCtlPeripheralEnable(SYSCTL_PERIPH_UART0);
-	SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA);
+    /* Enable the UART0 peripherals */
+    SysCtlPeripheralEnable(SYSCTL_PERIPH_UART0);
+    SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA);
 
-	/* Set GPIO A0 and A1 as UART pins. */
-	GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_0 | GPIO_PIN_1);
+    /* Set GPIO A0 and A1 as UART pins. */
+    GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_0 | GPIO_PIN_1);
 
-	/* Configure the UART for 115,200, 8-N-1 operation. */
-	UARTConfigSetExpClk(UART0_BASE, SysCtlClockGet(), 115200,
-	                    (UART_CONFIG_WLEN_8 | UART_CONFIG_STOP_ONE |
-	                     UART_CONFIG_PAR_NONE));
+    /* Configure the UART for 115,200, 8-N-1 operation. */
+    UARTConfigSetExpClk(UART0_BASE, SysCtlClockGet(), 115200,
+                        (UART_CONFIG_WLEN_8 | UART_CONFIG_STOP_ONE |
+                         UART_CONFIG_PAR_NONE));
 }
 
 /* write one character to serial, must not trigger interrupt */
 static void rt_hw_console_putc(const char c)
 {
-	if (c == '\n')
-		while(UARTCharPutNonBlocking(UART0_BASE, '\r') == false);
+    if (c == '\n')
+        while(UARTCharPutNonBlocking(UART0_BASE, '\r') == false);
 
-	while(UARTCharPutNonBlocking(UART0_BASE, c) == false);
+    while(UARTCharPutNonBlocking(UART0_BASE, c) == false);
 }
 
 /**
@@ -131,10 +131,10 @@ static void rt_hw_console_putc(const char c)
  */
 void rt_hw_console_output(const char* str)
 {
-	while (*str)
-	{
-		rt_hw_console_putc (*str++);
-	}
+    while (*str)
+    {
+        rt_hw_console_putc (*str++);
+    }
 }
 
 /*@}*/
diff --git a/bsp/lm3s9b9x/drivers/board.h b/bsp/lm3s9b9x/drivers/board.h
index 2270dc8313..cbce994f69 100644
--- a/bsp/lm3s9b9x/drivers/board.h
+++ b/bsp/lm3s9b9x/drivers/board.h
@@ -19,23 +19,23 @@
 
 /* whether use board external SRAM memory */
 // <e>Use external SRAM memory on the board
-// 	<i>Enable External SRAM memory
+//  <i>Enable External SRAM memory
 #define LM3S_EXT_SRAM          1
-//	<o>Begin Address of External SRAM
-//		<i>Default: 0x60000000
+//  <o>Begin Address of External SRAM
+//      <i>Default: 0x60000000
 #define LM3S_EXT_SRAM_BEGIN    0x60000000 /* the begining address of external SRAM */
-//	<o>End Address of External SRAM
-//		<i>Default: 0x60000000
+//  <o>End Address of External SRAM
+//      <i>Default: 0x60000000
 #define LM3S_EXT_SRAM_END      0x607FFFFF /* the end address of external SRAM */
 // </e>
 
 // <o> Internal SRAM memory size[Kbytes] <8-64>
-//	<i>Default: 64
+//  <i>Default: 64
 #define LM3S_SRAM_SIZE         96
 #define LM3S_SRAM_END          (0x20000000 + LM3S_SRAM_SIZE * 1024)
 
 // For lm3s9b9x, it should be SYSCTL_XTAL_16MHZ
-#define LM3S_XTAL_TYPE      	SYSCTL_XTAL_168MHZ
+#define LM3S_XTAL_TYPE          SYSCTL_XTAL_168MHZ
 
 void rt_hw_board_led_on(int n);
 void rt_hw_board_led_off(int n);
diff --git a/bsp/lm3s9b9x/drivers/serial.c b/bsp/lm3s9b9x/drivers/serial.c
index 0df347cf4b..b283600ecf 100644
--- a/bsp/lm3s9b9x/drivers/serial.c
+++ b/bsp/lm3s9b9x/drivers/serial.c
@@ -29,15 +29,15 @@ extern void rt_hw_interrupt_thread_switch(void);
 /* LM3S serial device */
 struct rt_lm3s_serial
 {
-	/* inherit from device */
-	struct rt_device parent;
+    /* inherit from device */
+    struct rt_device parent;
 
-	rt_uint32_t hw_base;
-	rt_uint32_t baudrate;
+    rt_uint32_t hw_base;
+    rt_uint32_t baudrate;
 
-	/* reception field */
-	rt_uint16_t save_index, read_index;
-	rt_uint8_t  rx_buffer[RT_UART_RX_BUFFER_SIZE];
+    /* reception field */
+    rt_uint16_t save_index, read_index;
+    rt_uint8_t  rx_buffer[RT_UART_RX_BUFFER_SIZE];
 };
 
 #ifdef RT_USING_UART1
@@ -63,72 +63,72 @@ void rt_hw_uart_isr(struct rt_lm3s_serial* serial)
     if (device->flag & RT_DEVICE_FLAG_INT_RX)
     {
         char ch;
-		rt_base_t level;
+        rt_base_t level;
 
         while (UARTCharsAvail(serial->hw_base))
         {
             ch = UARTCharGetNonBlocking(serial->hw_base);
 
             /* disable interrupt */
-			level = rt_hw_interrupt_disable();
+            level = rt_hw_interrupt_disable();
 
-			/* read character */
-			serial->rx_buffer[serial->save_index] = ch;
-			serial->save_index ++;
-			if (serial->save_index >= RT_UART_RX_BUFFER_SIZE)
-				serial->save_index = 0;
+            /* read character */
+            serial->rx_buffer[serial->save_index] = ch;
+            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 ++;
-				if (serial->read_index >= RT_UART_RX_BUFFER_SIZE)
-					serial->read_index = 0;
-			}
+            /* if the next position is read index, discard this 'read char' */
+            if (serial->save_index == serial->read_index)
+            {
+                serial->read_index ++;
+                if (serial->read_index >= RT_UART_RX_BUFFER_SIZE)
+                    serial->read_index = 0;
+            }
 
-			/* enable interrupt */
-			rt_hw_interrupt_enable(level);
+            /* enable interrupt */
+            rt_hw_interrupt_enable(level);
         }
 
-		/* invoke callback */
-		if(device->rx_indicate != RT_NULL)
-		{
-		    rt_int32_t length;
+        /* invoke callback */
+        if(device->rx_indicate != RT_NULL)
+        {
+            rt_int32_t length;
 
-		    length = serial->save_index - serial->read_index;
-		    if (length < 0) length += RT_UART_RX_BUFFER_SIZE;
+            length = serial->save_index - serial->read_index;
+            if (length < 0) length += RT_UART_RX_BUFFER_SIZE;
             device->rx_indicate(device, length);
-		}
+        }
     }
 }
 
 #ifdef RT_USING_UART1
 void rt_hw_uart_isr_1(int irqno)
 {
-	/* enter interrupt */
-	rt_interrupt_enter();
+    /* enter interrupt */
+    rt_interrupt_enter();
 
-	/* get serial device */
-	rt_hw_uart_isr(&serial1);
+    /* get serial device */
+    rt_hw_uart_isr(&serial1);
 
-	/* leave interrupt */
-	rt_interrupt_leave();
-	rt_hw_interrupt_thread_switch();
+    /* leave interrupt */
+    rt_interrupt_leave();
+    rt_hw_interrupt_thread_switch();
 }
 #endif
 
 #ifdef RT_USING_UART2
 void rt_hw_uart_isr_2(int irqno)
 {
-	/* enter interrupt */
-	rt_interrupt_enter();
+    /* enter interrupt */
+    rt_interrupt_enter();
 
-	/* get serial device */
-	rt_hw_uart_isr(&serial2);
+    /* get serial device */
+    rt_hw_uart_isr(&serial2);
 
-	/* leave interrupt */
-	rt_interrupt_leave();
-	rt_hw_interrupt_thread_switch();
+    /* leave interrupt */
+    rt_interrupt_leave();
+    rt_hw_interrupt_thread_switch();
 }
 #endif
 
@@ -139,15 +139,15 @@ void rt_hw_uart_isr_2(int irqno)
 
 static rt_err_t rt_serial_init (rt_device_t dev)
 {
-	return RT_EOK;
+    return RT_EOK;
 }
 
 static rt_err_t rt_serial_open(rt_device_t dev, rt_uint16_t oflag)
 {
-	struct rt_lm3s_serial* serial;
-	serial = (struct rt_lm3s_serial*) dev;
+    struct rt_lm3s_serial* serial;
+    serial = (struct rt_lm3s_serial*) dev;
 
-	RT_ASSERT(serial != RT_NULL);
+    RT_ASSERT(serial != RT_NULL);
 
     if (dev->flag & RT_DEVICE_FLAG_INT_RX)
     {
@@ -160,198 +160,198 @@ static rt_err_t rt_serial_open(rt_device_t dev, rt_uint16_t oflag)
         UARTIntEnable(serial->hw_base, UART_INT_RX | UART_INT_RT);
     }
 
-	return RT_EOK;
+    return RT_EOK;
 }
 
 static rt_err_t rt_serial_close(rt_device_t dev)
 {
-	struct rt_lm3s_serial* serial;
-	serial = (struct rt_lm3s_serial*) dev;
+    struct rt_lm3s_serial* serial;
+    serial = (struct rt_lm3s_serial*) dev;
 
-	RT_ASSERT(serial != RT_NULL);
+    RT_ASSERT(serial != RT_NULL);
 
-	if (dev->flag & RT_DEVICE_FLAG_INT_RX)
-	{
-		/* disable UART rx interrupt */
-		UARTIntDisable(serial->hw_base, UART_INT_RX | UART_INT_RT);
-	}
+    if (dev->flag & RT_DEVICE_FLAG_INT_RX)
+    {
+        /* disable UART rx interrupt */
+        UARTIntDisable(serial->hw_base, UART_INT_RX | UART_INT_RT);
+    }
 
-	return RT_EOK;
+    return RT_EOK;
 }
 
 static rt_err_t rt_serial_control(rt_device_t dev, int cmd, void *args)
 {
-	return RT_EOK;
+    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;
-	struct rt_lm3s_serial *serial = (struct rt_lm3s_serial*)dev;
-	RT_ASSERT(serial != RT_NULL);
+    rt_uint8_t* ptr;
+    struct rt_lm3s_serial *serial = (struct rt_lm3s_serial*)dev;
+    RT_ASSERT(serial != RT_NULL);
 
-	/* point to buffer */
-	ptr = (rt_uint8_t*) buffer;
+    /* point to buffer */
+    ptr = (rt_uint8_t*) buffer;
 
-	if (dev->flag & RT_DEVICE_FLAG_INT_RX)
-	{
-		while (size)
-		{
-			/* interrupt receive */
-			rt_base_t level;
+    if (dev->flag & RT_DEVICE_FLAG_INT_RX)
+    {
+        while (size)
+        {
+            /* interrupt receive */
+            rt_base_t level;
 
-			/* disable interrupt */
-			level = rt_hw_interrupt_disable();
-			if (serial->read_index != serial->save_index)
-			{
-				*ptr = serial->rx_buffer[serial->read_index];
+            /* disable interrupt */
+            level = rt_hw_interrupt_disable();
+            if (serial->read_index != serial->save_index)
+            {
+                *ptr = serial->rx_buffer[serial->read_index];
 
-				serial->read_index ++;
-				if (serial->read_index >= RT_UART_RX_BUFFER_SIZE)
-					serial->read_index = 0;
-			}
-			else
-			{
-				/* no data in rx buffer */
+                serial->read_index ++;
+                if (serial->read_index >= RT_UART_RX_BUFFER_SIZE)
+                    serial->read_index = 0;
+            }
+            else
+            {
+                /* no data in rx buffer */
 
-				/* enable interrupt */
-				rt_hw_interrupt_enable(level);
-				break;
-			}
+                /* enable interrupt */
+                rt_hw_interrupt_enable(level);
+                break;
+            }
 
-			/* enable interrupt */
-			rt_hw_interrupt_enable(level);
+            /* 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)
-	{
-		/* not support right now */
-		RT_ASSERT(0);
-	}
+        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);
+    }
 
-	/* polling mode */
-	while (size)
-	{
-	    *ptr = UARTCharGetNonBlocking(serial->hw_base);
+    /* polling mode */
+    while (size)
+    {
+        *ptr = UARTCharGetNonBlocking(serial->hw_base);
 
-	    ptr ++; size --;
-	}
+        ptr ++; size --;
+    }
 
-	return (rt_size_t)ptr - (rt_size_t)buffer;
+    return (rt_size_t)ptr - (rt_size_t)buffer;
 }
 
 static rt_size_t rt_serial_write(rt_device_t dev, rt_off_t pos, const void* buffer, rt_size_t size)
 {
-	struct rt_lm3s_serial* serial;
-	char *ptr;
+    struct rt_lm3s_serial* serial;
+    char *ptr;
 
-	serial = (struct rt_lm3s_serial*) dev;
-	if (dev->flag & RT_DEVICE_FLAG_INT_TX)
-	{
-		/* not support */
-		RT_ASSERT(0);
-	}
-	else if (dev->flag & RT_DEVICE_FLAG_DMA_TX)
-	{
-		/* not support */
-		RT_ASSERT(0);
-	}
+    serial = (struct rt_lm3s_serial*) dev;
+    if (dev->flag & RT_DEVICE_FLAG_INT_TX)
+    {
+        /* not support */
+        RT_ASSERT(0);
+    }
+    else if (dev->flag & RT_DEVICE_FLAG_DMA_TX)
+    {
+        /* not support */
+        RT_ASSERT(0);
+    }
 
-	/* polling write */
-	ptr = (char *)buffer;
+    /* polling write */
+    ptr = (char *)buffer;
 
-	if (dev->flag & RT_DEVICE_FLAG_STREAM)
-	{
-		/* stream mode */
-		while (size)
-		{
-			if (*ptr == '\n')
-				while (UARTCharPutNonBlocking(serial->hw_base, '\r') == false);
+    if (dev->flag & RT_DEVICE_FLAG_STREAM)
+    {
+        /* stream mode */
+        while (size)
+        {
+            if (*ptr == '\n')
+                while (UARTCharPutNonBlocking(serial->hw_base, '\r') == false);
 
-			while (UARTCharPutNonBlocking(serial->hw_base, *ptr) == false);
+            while (UARTCharPutNonBlocking(serial->hw_base, *ptr) == false);
 
-			ptr ++;
-			size --;
-		}
-	}
-	else
-	{
-		while (size)
-		{
-			while (UARTCharPutNonBlocking(serial->hw_base, *ptr) == false);
+            ptr ++;
+            size --;
+        }
+    }
+    else
+    {
+        while (size)
+        {
+            while (UARTCharPutNonBlocking(serial->hw_base, *ptr) == false);
 
-			ptr ++;
-			size --;
-		}
-	}
+            ptr ++;
+            size --;
+        }
+    }
 
-	return (rt_size_t) ptr - (rt_size_t) buffer;
+    return (rt_size_t) ptr - (rt_size_t) buffer;
 }
 
 void rt_hw_serial_init(void)
 {
-	struct rt_lm3s_serial* serial;
+    struct rt_lm3s_serial* serial;
 
 #ifdef RT_USING_UART1
-	serial = &serial1;
+    serial = &serial1;
 
-	serial->parent.type = RT_Device_Class_Char;
+    serial->parent.type = RT_Device_Class_Char;
 
-	serial->hw_base = UART0_BASE;
-	serial->baudrate = 115200;
+    serial->hw_base = UART0_BASE;
+    serial->baudrate = 115200;
 
-	rt_memset(serial->rx_buffer, 0, sizeof(serial->rx_buffer));
-	serial->read_index = serial->save_index = 0;
+    rt_memset(serial->rx_buffer, 0, sizeof(serial->rx_buffer));
+    serial->read_index = serial->save_index = 0;
 
-	/* enable UART0 clock */
+    /* enable UART0 clock */
     SysCtlPeripheralEnable(SYSCTL_PERIPH_UART0);
     SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA);
 
-	/* set UART0 pinmux */
+    /* set UART0 pinmux */
     GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_0 | GPIO_PIN_1);
 
-	/* Configure the UART for 115,200, 8-N-1 operation. */
-	UARTConfigSetExpClk(UART0_BASE, SysCtlClockGet(), serial->baudrate,
+    /* Configure the UART for 115,200, 8-N-1 operation. */
+    UARTConfigSetExpClk(UART0_BASE, SysCtlClockGet(), serial->baudrate,
                         (UART_CONFIG_WLEN_8 | UART_CONFIG_STOP_ONE |
                          UART_CONFIG_PAR_NONE));
 
-	serial->parent.init 	= rt_serial_init;
-	serial->parent.open 	= rt_serial_open;
-	serial->parent.close    = rt_serial_close;
-	serial->parent.read 	= rt_serial_read;
-	serial->parent.write    = rt_serial_write;
-	serial->parent.control  = rt_serial_control;
-	serial->parent.user_data  = RT_NULL;
+    serial->parent.init     = rt_serial_init;
+    serial->parent.open     = rt_serial_open;
+    serial->parent.close    = rt_serial_close;
+    serial->parent.read     = rt_serial_read;
+    serial->parent.write    = rt_serial_write;
+    serial->parent.control  = rt_serial_control;
+    serial->parent.user_data  = RT_NULL;
 
-	rt_device_register(&serial->parent,
-		"uart1", RT_DEVICE_FLAG_RDWR | RT_DEVICE_FLAG_INT_RX);
+    rt_device_register(&serial->parent,
+        "uart1", RT_DEVICE_FLAG_RDWR | RT_DEVICE_FLAG_INT_RX);
 #endif
 
 #ifdef RT_USING_UART2
-	serial = &serial2;
+    serial = &serial2;
 
-	serial->parent.type = RT_Device_Class_Char;
+    serial->parent.type = RT_Device_Class_Char;
 
-	serial->hw_base = 0xE0010000;
-	serial->baudrate = 115200;
+    serial->hw_base = 0xE0010000;
+    serial->baudrate = 115200;
 
-	rt_memset(serial->rx_buffer, 0, sizeof(serial->rx_buffer));
-	serial->read_index = serial->save_index = 0;
+    rt_memset(serial->rx_buffer, 0, sizeof(serial->rx_buffer));
+    serial->read_index = serial->save_index = 0;
 
-	serial->parent.init 	= rt_serial_init;
-	serial->parent.open 	= rt_serial_open;
-	serial->parent.close    = rt_serial_close;
-	serial->parent.read 	= rt_serial_read;
-	serial->parent.write    = rt_serial_write;
-	serial->parent.control  = rt_serial_control;
-	serial->parent.user_data  = RT_NULL;
+    serial->parent.init     = rt_serial_init;
+    serial->parent.open     = rt_serial_open;
+    serial->parent.close    = rt_serial_close;
+    serial->parent.read     = rt_serial_read;
+    serial->parent.write    = rt_serial_write;
+    serial->parent.control  = rt_serial_control;
+    serial->parent.user_data  = RT_NULL;
 
-	rt_device_register(&serial->parent,
-		"uart2", RT_DEVICE_FLAG_RDWR | RT_DEVICE_FLAG_INT_RX);
+    rt_device_register(&serial->parent,
+        "uart2", RT_DEVICE_FLAG_RDWR | RT_DEVICE_FLAG_INT_RX);
 #endif
 }