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

[lts 3.1.x] format codes

4 files changed, 206 insertions, 206 deletions

diff --git a/libcpu/avr32/uc3/cpu.c b/libcpu/avr32/uc3/cpu.c
index b77e78dc5b..190ce93257 100644
--- a/libcpu/avr32/uc3/cpu.c
+++ b/libcpu/avr32/uc3/cpu.c
@@ -25,7 +25,7 @@
  */
 void rt_hw_cpu_reset()
 {
-	/*NOTREACHED*/
+    /*NOTREACHED*/
 }
 
 /**
@@ -34,9 +34,9 @@ void rt_hw_cpu_reset()
  */
 void rt_hw_cpu_shutdown()
 {
-	rt_kprintf("shutdown...\n");
+    rt_kprintf("shutdown...\n");
 
-	RT_ASSERT(0);
+    RT_ASSERT(0);
 }
 
 /*@}*/
diff --git a/libcpu/avr32/uc3/serial.c b/libcpu/avr32/uc3/serial.c
index 14ef865448..66fb6ca8b9 100644
--- a/libcpu/avr32/uc3/serial.c
+++ b/libcpu/avr32/uc3/serial.c
@@ -24,8 +24,8 @@ struct rt_device _rt_usart_device;
 struct avr32_serial_int_rx _rt_usart_rx;
 struct avr32_serial_device uart =
 {
-	.uart_device = (avr32_usart_t *) &AVR32_USART1,
-	.int_rx = &_rt_usart_rx
+    .uart_device = (avr32_usart_t *) &AVR32_USART1,
+    .int_rx = &_rt_usart_rx
 };
 
 /**
@@ -36,163 +36,163 @@ struct avr32_serial_device uart =
 /* RT-Thread Device Interface */
 static rt_err_t rt_serial_init (rt_device_t dev)
 {
-	struct avr32_serial_device* uart = (struct avr32_serial_device*) dev->user_data;
+    struct avr32_serial_device* uart = (struct avr32_serial_device*) dev->user_data;
 
-	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 = 0;
-			uart->int_rx->save_index = 0;
-		}
+    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 = 0;
+            uart->int_rx->save_index = 0;
+        }
 
-		dev->flag |= RT_DEVICE_FLAG_ACTIVATED;
-	}
+        dev->flag |= RT_DEVICE_FLAG_ACTIVATED;
+    }
 
-	return RT_EOK;
+    return RT_EOK;
 }
 
 static rt_err_t rt_serial_open(rt_device_t dev, rt_uint16_t oflag)
 {
-	return RT_EOK;
+    return RT_EOK;
 }
 
 static rt_err_t rt_serial_close(rt_device_t dev)
 {
-	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;
-	rt_err_t err_code;
-	struct avr32_serial_device* uart;
+    rt_uint8_t* ptr;
+    rt_err_t err_code;
+    struct avr32_serial_device* uart;
 
-	ptr = buffer;
-	err_code = RT_EOK;
-	uart = (struct avr32_serial_device*)dev->user_data;
+    ptr = buffer;
+    err_code = RT_EOK;
+    uart = (struct avr32_serial_device*)dev->user_data;
 
-	if (dev->flag & RT_DEVICE_FLAG_INT_RX)
-	{
-		/* interrupt mode Rx */
-		while (size)
-		{
-			rt_base_t level;
+    if (dev->flag & RT_DEVICE_FLAG_INT_RX)
+    {
+        /* interrupt mode Rx */
+        while (size)
+        {
+            rt_base_t level;
 
-			/* disable interrupt */
-			level = rt_hw_interrupt_disable();
+            /* disable interrupt */
+            level = rt_hw_interrupt_disable();
 
-			if (uart->int_rx->read_index != uart->int_rx->save_index)
-			{
-				/* read a character */
-				*ptr++ = uart->int_rx->rx_buffer[uart->int_rx->read_index];
-				size--;
+            if (uart->int_rx->read_index != uart->int_rx->save_index)
+            {
+                /* read a character */
+                *ptr++ = uart->int_rx->rx_buffer[uart->int_rx->read_index];
+                size--;
 
-				/* move to next position */
-				uart->int_rx->read_index ++;
-				if (uart->int_rx->read_index >= UART_RX_BUFFER_SIZE)
-					uart->int_rx->read_index = 0;
-			}
-			else
-			{
-				/* set error code */
-				err_code = -RT_EEMPTY;
+                /* move to next position */
+                uart->int_rx->read_index ++;
+                if (uart->int_rx->read_index >= UART_RX_BUFFER_SIZE)
+                    uart->int_rx->read_index = 0;
+            }
+            else
+            {
+                /* set error code */
+                err_code = -RT_EEMPTY;
 
-				/* enable interrupt */
-				rt_hw_interrupt_enable(level);
-				break;
-			}
+                /* enable interrupt */
+                rt_hw_interrupt_enable(level);
+                break;
+            }
 
-			/* enable interrupt */
-			rt_hw_interrupt_enable(level);
-		}
-	}
-	else
-	{
-		/* polling mode */
-		while ((rt_uint32_t)ptr - (rt_uint32_t)buffer < size)
-		{
-			while (usart_test_hit(uart->uart_device))
-			{
-				*ptr = uart->uart_device->rhr & 0xff;
-				ptr ++;
-			}
-		}
-	}
+            /* enable interrupt */
+            rt_hw_interrupt_enable(level);
+        }
+    }
+    else
+    {
+        /* polling mode */
+        while ((rt_uint32_t)ptr - (rt_uint32_t)buffer < size)
+        {
+            while (usart_test_hit(uart->uart_device))
+            {
+                *ptr = uart->uart_device->rhr & 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 avr32_serial_device* uart;
+    rt_uint8_t* ptr;
+    rt_err_t err_code;
+    struct avr32_serial_device* uart;
 
-	err_code = RT_EOK;
-	ptr = (rt_uint8_t*)buffer;
-	uart = (struct avr32_serial_device*)dev->user_data;
+    err_code = RT_EOK;
+    ptr = (rt_uint8_t*)buffer;
+    uart = (struct avr32_serial_device*)dev->user_data;
 
-	if (dev->flag & RT_DEVICE_FLAG_INT_TX)
-	{
-		/* interrupt mode Tx, does not support */
-		RT_ASSERT(0);
-	}
-	else
-	{
-		/* polling mode */
-		if (dev->flag & RT_DEVICE_FLAG_STREAM)
-		{
-			/* stream mode */
-			while (size)
-			{
-				usart_putchar(uart->uart_device, (int) *ptr);
+    if (dev->flag & RT_DEVICE_FLAG_INT_TX)
+    {
+        /* interrupt mode Tx, does not support */
+        RT_ASSERT(0);
+    }
+    else
+    {
+        /* polling mode */
+        if (dev->flag & RT_DEVICE_FLAG_STREAM)
+        {
+            /* stream mode */
+            while (size)
+            {
+                usart_putchar(uart->uart_device, (int) *ptr);
 
-				++ptr; --size;
-			}
-		}
-		else
-		{
-			/* write data directly */
-			while (size)
-			{
-				usart_bw_write_char(uart->uart_device, (int) *ptr);
+                ++ptr; --size;
+            }
+        }
+        else
+        {
+            /* write data directly */
+            while (size)
+            {
+                usart_bw_write_char(uart->uart_device, (int) *ptr);
 
-				++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)
 {
-	struct avr32_serial_device* uart;
+    struct avr32_serial_device* uart;
 
-	RT_ASSERT(dev != RT_NULL);
+    RT_ASSERT(dev != RT_NULL);
 
-	uart = (struct avr32_serial_device*)dev->user_data;
-	switch (cmd)
-	{
-	case RT_DEVICE_CTRL_SUSPEND:
-		/* suspend device */
-		dev->flag |= RT_DEVICE_FLAG_SUSPENDED;
-		break;
+    uart = (struct avr32_serial_device*)dev->user_data;
+    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;
 }
 
 /*
@@ -201,77 +201,77 @@ 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 avr32_serial_device *serial)
 {
-	RT_ASSERT(device != RT_NULL);
+    RT_ASSERT(device != RT_NULL);
 
-	if ((flag & RT_DEVICE_FLAG_DMA_RX) ||
-		(flag & RT_DEVICE_FLAG_INT_TX))
-	{
-		RT_ASSERT(0);
-	}
+    if ((flag & RT_DEVICE_FLAG_DMA_RX) ||
+        (flag & RT_DEVICE_FLAG_INT_TX))
+    {
+        RT_ASSERT(0);
+    }
 
-	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(void)
 {
-	struct avr32_serial_device* uart = (struct avr32_serial_device*) _rt_usart_device.user_data;
-	rt_base_t level;
+    struct avr32_serial_device* uart = (struct avr32_serial_device*) _rt_usart_device.user_data;
+    rt_base_t level;
 
-	if (usart_test_hit(uart->uart_device))
-	{
-		/* interrupt mode receive */
-		RT_ASSERT(device->flag & RT_DEVICE_FLAG_INT_RX);
+    if (usart_test_hit(uart->uart_device))
+    {
+        /* interrupt mode receive */
+        RT_ASSERT(device->flag & RT_DEVICE_FLAG_INT_RX);
 
-		/* disable interrupt */
-		level = rt_hw_interrupt_disable();
+        /* disable interrupt */
+        level = rt_hw_interrupt_disable();
 
-		/* save character */
-		uart->int_rx->rx_buffer[uart->int_rx->save_index] = uart->uart_device->rhr & 0xff;
-		uart->int_rx->save_index ++;
-		if (uart->int_rx->save_index >= UART_RX_BUFFER_SIZE)
-			uart->int_rx->save_index = 0;
+        /* save character */
+        uart->int_rx->rx_buffer[uart->int_rx->save_index] = uart->uart_device->rhr & 0xff;
+        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);
 
-		/* invoke callback */
-		if (_rt_usart_device.rx_indicate != RT_NULL)
-		{
-			rt_size_t rx_length;
+        /* invoke callback */
+        if (_rt_usart_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;
 
-			_rt_usart_device.rx_indicate(&_rt_usart_device, rx_length);
-		}
-	}
-	else
-	{
-		usart_reset_status(uart->uart_device);
-	}
+            _rt_usart_device.rx_indicate(&_rt_usart_device, rx_length);
+        }
+    }
+    else
+    {
+        usart_reset_status(uart->uart_device);
+    }
 }
 
 /*@}*/
diff --git a/libcpu/avr32/uc3/serial.h b/libcpu/avr32/uc3/serial.h
index a17338701b..fef65a12be 100644
--- a/libcpu/avr32/uc3/serial.h
+++ b/libcpu/avr32/uc3/serial.h
@@ -21,29 +21,29 @@
 #include "compiler.h"
 #include "usart.h"
 
-#define UART_RX_BUFFER_SIZE		64
-#define UART_TX_DMA_NODE_SIZE	4
+#define UART_RX_BUFFER_SIZE     64
+#define UART_TX_DMA_NODE_SIZE   4
 
 /* data node for Tx Mode */
 struct avr32_serial_data_node
 {
-	rt_uint8_t *data_ptr;
-	rt_size_t  data_size;
-	struct avr32_serial_data_node *next, *prev;
+    rt_uint8_t *data_ptr;
+    rt_size_t  data_size;
+    struct avr32_serial_data_node *next, *prev;
 };
 
 struct avr32_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 avr32_serial_device
 {
-	avr32_usart_t *uart_device;
+    avr32_usart_t *uart_device;
 
-	/* rx structure */
-	struct avr32_serial_int_rx* int_rx;
+    /* rx structure */
+    struct avr32_serial_int_rx* int_rx;
 };
 
 rt_err_t rt_hw_serial_register(rt_device_t device, const char* name, rt_uint32_t flag, struct avr32_serial_device *serial);
diff --git a/libcpu/avr32/uc3/stack.c b/libcpu/avr32/uc3/stack.c
index dd43b5edbc..dee1161c12 100644
--- a/libcpu/avr32/uc3/stack.c
+++ b/libcpu/avr32/uc3/stack.c
@@ -30,28 +30,28 @@
  */
 rt_uint8_t *rt_hw_stack_init(void *tentry, void *parameter, rt_uint8_t *stack_addr, void *texit)
 {
-	unsigned long *stk;
+    unsigned long *stk;
 
-	stk 	 = (unsigned long *)stack_addr;
-	*(stk)   = 0;							/* r8 */
-	*(--stk) = 0;							/* r9 */
-	*(--stk) = 0;							/* r10 */
-	*(--stk) = 0;							/* r11 */
-	*(--stk) = 0;							/* r12 */
-	*(--stk) = (unsigned long)texit;		/* lr */
-	*(--stk) = (unsigned long)tentry;		/* entry point, pc */
-	*(--stk) = 0x00600000;					/* sr */
-	*(--stk) = 0;							/* r0 */
-	*(--stk) = 0;							/* r1 */
-	*(--stk) = 0;							/* r2 */
-	*(--stk) = 0;							/* r3 */
-	*(--stk) = 0;							/* r4 */
-	*(--stk) = 0;							/* r5 */
-	*(--stk) = 0;							/* r6 */
-	*(--stk) = 0;							/* r7 */
+    stk      = (unsigned long *)stack_addr;
+    *(stk)   = 0;                           /* r8 */
+    *(--stk) = 0;                           /* r9 */
+    *(--stk) = 0;                           /* r10 */
+    *(--stk) = 0;                           /* r11 */
+    *(--stk) = 0;                           /* r12 */
+    *(--stk) = (unsigned long)texit;        /* lr */
+    *(--stk) = (unsigned long)tentry;       /* entry point, pc */
+    *(--stk) = 0x00600000;                  /* sr */
+    *(--stk) = 0;                           /* r0 */
+    *(--stk) = 0;                           /* r1 */
+    *(--stk) = 0;                           /* r2 */
+    *(--stk) = 0;                           /* r3 */
+    *(--stk) = 0;                           /* r4 */
+    *(--stk) = 0;                           /* r5 */
+    *(--stk) = 0;                           /* r6 */
+    *(--stk) = 0;                           /* r7 */
 
-	/* return task's current stack address */
-	return (rt_uint8_t *)stk;
+    /* return task's current stack address */
+    return (rt_uint8_t *)stk;
 }
 
 /*@}*/