3 files changed, 319 insertions, 301 deletions
diff --git a/components/drivers/src/completion.c b/components/drivers/src/completion.c
index 39814a3d4f..17ca1fa406 100644
--- a/components/drivers/src/completion.c
+++ b/components/drivers/src/completion.c
@@ -16,108 +16,110 @@
 #include <rtthread.h>
 #include <rtdevice.h>
 
-#define RT_COMPLETED	1
-#define RT_UNCOMPLETED	0
+#define RT_COMPLETED    1
+#define RT_UNCOMPLETED  0
 
-void rt_completion_init(struct rt_completion* completion)
+void rt_completion_init(struct rt_completion *completion)
 {
-	rt_base_t level;
-	RT_ASSERT(completion != RT_NULL);
+    rt_base_t level;
+    RT_ASSERT(completion != RT_NULL);
 
-	level = rt_hw_interrupt_disable();
-	completion->flag = RT_UNCOMPLETED;
-	rt_list_init(&completion->suspended_list);
-	rt_hw_interrupt_enable(level);
+    level = rt_hw_interrupt_disable();
+    completion->flag = RT_UNCOMPLETED;
+    rt_list_init(&completion->suspended_list);
+    rt_hw_interrupt_enable(level);
 }
 
-rt_err_t rt_completion_wait(struct rt_completion* completion, rt_int32_t timeout)
+rt_err_t rt_completion_wait(struct rt_completion *completion,
+                            rt_int32_t            timeout)
 {
-	rt_err_t result;
-	rt_base_t level;
-	rt_thread_t thread;
-	RT_ASSERT(completion != RT_NULL);
+    rt_err_t result;
+    rt_base_t level;
+    rt_thread_t thread;
+    RT_ASSERT(completion != RT_NULL);
 
-	result = RT_EOK;
-	thread = rt_thread_self();
+    result = RT_EOK;
+    thread = rt_thread_self();
 
-	level = rt_hw_interrupt_disable();
-	if (completion->flag != RT_COMPLETED)
-	{
-		/* only one thread can suspend on complete */
-		RT_ASSERT(rt_list_isempty(&(completion->suspended_list)));
+    level = rt_hw_interrupt_disable();
+    if (completion->flag != RT_COMPLETED)
+    {
+        /* only one thread can suspend on complete */
+        RT_ASSERT(rt_list_isempty(&(completion->suspended_list)));
 
-		if (timeout == 0)
-		{
-			result = -RT_ETIMEOUT;
-			goto __exit;
-		}
-		else
-		{
-			/* reset thread error number */
-			thread->error = RT_EOK;
-			
-			/* suspend thread */
-			rt_thread_suspend(thread);
-			/* add to suspended list */
-			rt_list_insert_before(&(completion->suspended_list), &(thread->tlist));
+        if (timeout == 0)
+        {
+            result = -RT_ETIMEOUT;
+            goto __exit;
+        }
+        else
+        {
+            /* reset thread error number */
+            thread->error = RT_EOK;
 
-			/* current context checking */
-			RT_DEBUG_NOT_IN_INTERRUPT;
+            /* suspend thread */
+            rt_thread_suspend(thread);
+            /* add to suspended list */
+            rt_list_insert_before(&(completion->suspended_list), &(thread->tlist));
 
-			/* start timer */
-			if (timeout > 0)
-			{
-				/* reset the timeout of thread timer and start it */
-				rt_timer_control(&(thread->thread_timer), RT_TIMER_CTRL_SET_TIME, &timeout);
-				rt_timer_start(&(thread->thread_timer));
-			}
-			/* enable interrupt */
-			rt_hw_interrupt_enable(level);
+            /* current context checking */
+            RT_DEBUG_NOT_IN_INTERRUPT;
 
-			/* do schedule */
-			rt_schedule();
+            /* start timer */
+            if (timeout > 0)
+            {
+                /* reset the timeout of thread timer and start it */
+                rt_timer_control(&(thread->thread_timer), RT_TIMER_CTRL_SET_TIME, &timeout);
+                rt_timer_start(&(thread->thread_timer));
+            }
+            /* enable interrupt */
+            rt_hw_interrupt_enable(level);
 
-			/* thread is waked up */
-			result = thread->error;
+            /* do schedule */
+            rt_schedule();
 
-			level = rt_hw_interrupt_disable();
-			/* clean completed flag */
-			completion->flag = RT_UNCOMPLETED;
-		}
-	}
+            /* thread is waked up */
+            result = thread->error;
+
+            level = rt_hw_interrupt_disable();
+            /* clean completed flag */
+            completion->flag = RT_UNCOMPLETED;
+        }
+    }
 
 __exit:
-	rt_hw_interrupt_enable(level);
-	return result;
+    rt_hw_interrupt_enable(level);
+    return result;
 }
 
-void rt_completion_done(struct rt_completion* completion)
+void rt_completion_done(struct rt_completion *completion)
 {
-	rt_base_t level;
-	RT_ASSERT(completion != RT_NULL);
+    rt_base_t level;
+    RT_ASSERT(completion != RT_NULL);
 
-	if(completion->flag == RT_COMPLETED) return;
+    if (completion->flag == RT_COMPLETED)
+        return;
 
-	level = rt_hw_interrupt_disable();
-	completion->flag = RT_COMPLETED;
+    level = rt_hw_interrupt_disable();
+    completion->flag = RT_COMPLETED;
 
-	if (!rt_list_isempty(&(completion->suspended_list)))
-	{
-		/* there is one thread in suspended list */
-		struct rt_thread *thread;
+    if (!rt_list_isempty(&(completion->suspended_list)))
+    {
+        /* there is one thread in suspended list */
+        struct rt_thread *thread;
 
-		/* get thread entry */
-		thread = rt_list_entry(completion->suspended_list.next, struct rt_thread, tlist);
-		
-		/* resume it */
-		rt_thread_resume(thread);
-		rt_hw_interrupt_enable(level);
+        /* get thread entry */
+        thread = rt_list_entry(completion->suspended_list.next, struct rt_thread, tlist);
+        
+        /* resume it */
+        rt_thread_resume(thread);
+        rt_hw_interrupt_enable(level);
 
-		/* perform a schedule */
-		rt_schedule();
-	}
-	else
-	{
-		rt_hw_interrupt_enable(level);
-	}
+        /* perform a schedule */
+        rt_schedule();
+    }
+    else
+    {
+        rt_hw_interrupt_enable(level);
+    }
 }
diff --git a/components/drivers/src/pipe.c b/components/drivers/src/pipe.c
index 142f1d9399..00aa863c8c 100644
--- a/components/drivers/src/pipe.c
+++ b/components/drivers/src/pipe.c
@@ -11,186 +11,195 @@
  * Date           Author       Notes
  * 2012-09-30     Bernard      first version.
  */
+
 #include <rthw.h>
 #include <rtthread.h>
 #include <rtdevice.h>
 
-static rt_size_t rt_pipe_read(rt_device_t dev, rt_off_t pos, void *buffer, rt_size_t size)
+static rt_size_t rt_pipe_read(rt_device_t dev,
+                              rt_off_t    pos,
+                              void       *buffer,
+                              rt_size_t   size)
 {
-	rt_uint32_t level;
-	rt_thread_t thread;
-	struct rt_pipe_device *pipe;
-	rt_size_t read_nbytes;
+    rt_uint32_t level;
+    rt_thread_t thread;
+    struct rt_pipe_device *pipe;
+    rt_size_t read_nbytes;
 
-	pipe = PIPE_DEVICE(dev);
-	RT_ASSERT(pipe != RT_NULL);
+    pipe = PIPE_DEVICE(dev);
+    RT_ASSERT(pipe != RT_NULL);
 
-	thread = rt_thread_self();
+    thread = rt_thread_self();
 
-	/* current context checking */
-	RT_DEBUG_NOT_IN_INTERRUPT;
+    /* current context checking */
+    RT_DEBUG_NOT_IN_INTERRUPT;
 
-	do 
-	{
-		level = rt_hw_interrupt_disable();
-		read_nbytes = rt_ringbuffer_get(&(pipe->ringbuffer), buffer, size);
-		if (read_nbytes == 0)
-		{
-			rt_thread_suspend(thread);
-			/* waiting on suspended read list */
-			rt_list_insert_before(&(pipe->suspended_read_list), &(thread->tlist));
-			rt_hw_interrupt_enable(level);
+    do 
+    {
+        level = rt_hw_interrupt_disable();
+        read_nbytes = rt_ringbuffer_get(&(pipe->ringbuffer), buffer, size);
+        if (read_nbytes == 0)
+        {
+            rt_thread_suspend(thread);
+            /* waiting on suspended read list */
+            rt_list_insert_before(&(pipe->suspended_read_list), &(thread->tlist));
+            rt_hw_interrupt_enable(level);
 
-			rt_schedule();
-		}
-		else
-		{
-			if (!rt_list_isempty(&pipe->suspended_write_list))
-			{
-				/* get suspended thread */
-				thread = rt_list_entry(pipe->suspended_write_list.next, 
-					struct rt_thread, tlist);
+            rt_schedule();
+        }
+        else
+        {
+            if (!rt_list_isempty(&pipe->suspended_write_list))
+            {
+                /* get suspended thread */
+                thread = rt_list_entry(pipe->suspended_write_list.next, 
+                    struct rt_thread, tlist);
 
-				/* resume the write thread */
-				rt_thread_resume(thread);
-				rt_hw_interrupt_enable(level);
+                /* resume the write thread */
+                rt_thread_resume(thread);
+                rt_hw_interrupt_enable(level);
 
-				rt_schedule();
-			}
-			else
-			{
-				rt_hw_interrupt_enable(level);
-			}
-			break;
-		}
-	} while (read_nbytes == 0);
+                rt_schedule();
+            }
+            else
+            {
+                rt_hw_interrupt_enable(level);
+            }
+            break;
+        }
+    } while (read_nbytes == 0);
 
-	return read_nbytes;
+    return read_nbytes;
 }
 
 struct rt_pipe_device *_pipe = RT_NULL;
-static rt_size_t rt_pipe_write(rt_device_t dev, rt_off_t pos, const void *buffer, rt_size_t size)
+static rt_size_t rt_pipe_write(rt_device_t dev,
+                               rt_off_t    pos,
+                               const void *buffer,
+                               rt_size_t   size)
 {
-	rt_uint32_t level;
-	rt_thread_t thread;
-	struct rt_pipe_device *pipe;
-	rt_size_t write_nbytes;
+    rt_uint32_t level;
+    rt_thread_t thread;
+    struct rt_pipe_device *pipe;
+    rt_size_t write_nbytes;
+
+    pipe = PIPE_DEVICE(dev);
+    RT_ASSERT(pipe != RT_NULL);
+    if (_pipe == RT_NULL)
+        _pipe = pipe;
 
-	pipe = PIPE_DEVICE(dev);
-	RT_ASSERT(pipe != RT_NULL);
-	if (_pipe == RT_NULL)
-		_pipe = pipe;
-	
-	thread = rt_thread_self();
+    thread = rt_thread_self();
 
-	/* current context checking */
-	RT_DEBUG_NOT_IN_INTERRUPT;
+    /* current context checking */
+    RT_DEBUG_NOT_IN_INTERRUPT;
 
-	do 
-	{
-		level = rt_hw_interrupt_disable();
-		write_nbytes = rt_ringbuffer_put(&(pipe->ringbuffer), buffer, size);
-		if (write_nbytes == 0)
-		{
-			/* pipe full, waiting on suspended write list */
-			rt_thread_suspend(thread);
-			/* waiting on suspended read list */
-			rt_list_insert_before(&(pipe->suspended_write_list), &(thread->tlist));
-			rt_hw_interrupt_enable(level);
+    do 
+    {
+        level = rt_hw_interrupt_disable();
+        write_nbytes = rt_ringbuffer_put(&(pipe->ringbuffer), buffer, size);
+        if (write_nbytes == 0)
+        {
+            /* pipe full, waiting on suspended write list */
+            rt_thread_suspend(thread);
+            /* waiting on suspended read list */
+            rt_list_insert_before(&(pipe->suspended_write_list), &(thread->tlist));
+            rt_hw_interrupt_enable(level);
 
-			rt_schedule();
-		}
-		else
-		{
-			if (!rt_list_isempty(&pipe->suspended_read_list))
-			{
-				/* get suspended thread */
-				thread = rt_list_entry(pipe->suspended_read_list.next, 
-					struct rt_thread, tlist);
+            rt_schedule();
+        }
+        else
+        {
+            if (!rt_list_isempty(&pipe->suspended_read_list))
+            {
+                /* get suspended thread */
+                thread = rt_list_entry(pipe->suspended_read_list.next,
+                                       struct rt_thread, tlist);
 
-				/* resume the read thread */
-				rt_thread_resume(thread);
-				rt_hw_interrupt_enable(level);
+                /* resume the read thread */
+                rt_thread_resume(thread);
+                rt_hw_interrupt_enable(level);
 
-				rt_schedule();
-			}
-			else
-			{
-				rt_hw_interrupt_enable(level);
-			}
-			break;
-		}
-	}while (write_nbytes == 0);
+                rt_schedule();
+            }
+            else
+            {
+                rt_hw_interrupt_enable(level);
+            }
+            break;
+        }
+    }while (write_nbytes == 0);
 
-	return write_nbytes;
+    return write_nbytes;
 }
 
 static rt_err_t rt_pipe_control(rt_device_t dev, rt_uint8_t cmd, void *args)
 {
-	return RT_EOK;
+    return RT_EOK;
 }
 
-rt_err_t rt_pipe_create(const char* name, rt_size_t size)
+rt_err_t rt_pipe_create(const char *name, rt_size_t size)
 {
-	rt_err_t result = RT_EOK;
-	rt_uint8_t* rb_memptr = RT_NULL;
-	struct rt_pipe_device *pipe = RT_NULL;
+    rt_err_t result = RT_EOK;
+    rt_uint8_t *rb_memptr = RT_NULL;
+    struct rt_pipe_device *pipe = RT_NULL;
 
-	/* get aligned size */
-	size = RT_ALIGN(size, RT_ALIGN_SIZE);
-	pipe = (struct rt_pipe_device*) rt_calloc (1, sizeof(struct rt_pipe_device));
-	if (pipe != RT_NULL)
-	{
-		/* create ring buffer of pipe */
-		rb_memptr = rt_malloc(size);
-		if (rb_memptr == RT_NULL)
-		{
-			result = -RT_ENOMEM;
-			goto __exit;
-		}
-		/* initialize suspended list */
-		rt_list_init(&pipe->suspended_read_list);
-		rt_list_init(&pipe->suspended_write_list);
-		
-		/* initialize ring buffer */
-		rt_ringbuffer_init(&pipe->ringbuffer, rb_memptr, size);
+    /* get aligned size */
+    size = RT_ALIGN(size, RT_ALIGN_SIZE);
+    pipe = (struct rt_pipe_device *)rt_calloc(1, sizeof(struct rt_pipe_device));
+    if (pipe != RT_NULL)
+    {
+        /* create ring buffer of pipe */
+        rb_memptr = rt_malloc(size);
+        if (rb_memptr == RT_NULL)
+        {
+            result = -RT_ENOMEM;
+            goto __exit;
+        }
+        /* initialize suspended list */
+        rt_list_init(&pipe->suspended_read_list);
+        rt_list_init(&pipe->suspended_write_list);
+        
+        /* initialize ring buffer */
+        rt_ringbuffer_init(&pipe->ringbuffer, rb_memptr, size);
 
-		/* create device */
-		pipe->parent.type 	= RT_Device_Class_Char;
-		pipe->parent.init 	= RT_NULL;
-		pipe->parent.open 	= RT_NULL;
-		pipe->parent.close 	= RT_NULL;
-		pipe->parent.read 	= rt_pipe_read;
-		pipe->parent.write 	= rt_pipe_write;
-		pipe->parent.control = rt_pipe_control;
+        /* create device */
+        pipe->parent.type    = RT_Device_Class_Char;
+        pipe->parent.init    = RT_NULL;
+        pipe->parent.open    = RT_NULL;
+        pipe->parent.close   = RT_NULL;
+        pipe->parent.read    = rt_pipe_read;
+        pipe->parent.write   = rt_pipe_write;
+        pipe->parent.control = rt_pipe_control;
 
-		return rt_device_register(&(pipe->parent), name, RT_DEVICE_FLAG_RDWR);
-	}
-	else
-	{
-		result = -RT_ENOMEM;
-	}
+        return rt_device_register(&(pipe->parent), name, RT_DEVICE_FLAG_RDWR);
+    }
+    else
+    {
+        result = -RT_ENOMEM;
+    }
 
 __exit:
-	if (pipe != RT_NULL) rt_free(pipe);
-	if (rb_memptr != RT_NULL) rt_free(rb_memptr);
+    if (pipe != RT_NULL)
+        rt_free(pipe);
+    if (rb_memptr != RT_NULL)
+        rt_free(rb_memptr);
 
-	return result;
+    return result;
 }
 RTM_EXPORT(rt_pipe_create);
 
-void rt_pipe_destroy(struct rt_pipe_device* pipe)
+void rt_pipe_destroy(struct rt_pipe_device *pipe)
 {
-	if (pipe == RT_NULL) return;
+    if (pipe == RT_NULL)
+        return;
 
-	/* un-register pipe device */
-	rt_device_unregister(&(pipe->parent));
+    /* un-register pipe device */
+    rt_device_unregister(&(pipe->parent));
 
-	/* release memory */
-	rt_free(pipe->ringbuffer.buffer_ptr);
-	rt_free(pipe);
+    /* release memory */
+    rt_free(pipe->ringbuffer.buffer_ptr);
+    rt_free(pipe);
 
-	return;
+    return;
 }
 RTM_EXPORT(rt_pipe_destroy);
-
diff --git a/components/drivers/src/ringbuffer.c b/components/drivers/src/ringbuffer.c
index 0b1bee1906..6223ba6935 100644
--- a/components/drivers/src/ringbuffer.c
+++ b/components/drivers/src/ringbuffer.c
@@ -16,51 +16,56 @@
 #include <rtdevice.h>
 #include <string.h>
 
-void rt_ringbuffer_init(struct rt_ringbuffer* rb, rt_uint8_t *pool, rt_uint16_t size)
+void rt_ringbuffer_init(struct rt_ringbuffer *rb,
+                        rt_uint8_t           *pool,
+                        rt_uint16_t           size)
 {
-	RT_ASSERT(rb != RT_NULL);
+    RT_ASSERT(rb != RT_NULL);
 
-	/* initialize read and write index */
-	rb->read_index = rb->write_index = 0;
+    /* initialize read and write index */
+    rb->read_index = rb->write_index = 0;
 
-	/* set buffer pool and size */
-	rb->buffer_ptr = pool;
-	rb->buffer_size = RT_ALIGN_DOWN(size, RT_ALIGN_SIZE);
+    /* set buffer pool and size */
+    rb->buffer_ptr = pool;
+    rb->buffer_size = RT_ALIGN_DOWN(size, RT_ALIGN_SIZE);
 }
 RTM_EXPORT(rt_ringbuffer_init);
 
-rt_size_t rt_ringbuffer_put(struct rt_ringbuffer* rb, const rt_uint8_t *ptr, rt_uint16_t length)
+rt_size_t rt_ringbuffer_put(struct rt_ringbuffer *rb,
+                            const rt_uint8_t     *ptr,
+                            rt_uint16_t           length)
 {
-	rt_uint16_t size;
-	rt_uint16_t mask;
-	rt_uint16_t write_position;
-	
-	RT_ASSERT(rb != RT_NULL);
+    rt_uint16_t size;
+    rt_uint16_t mask;
+    rt_uint16_t write_position;
+    
+    RT_ASSERT(rb != RT_NULL);
 
-	mask = rb->buffer_size - 1;
-	/* whether has enough space */
-	size = rb->buffer_size - (rb->write_index - rb->read_index);
+    mask = rb->buffer_size - 1;
+    /* whether has enough space */
+    size = rb->buffer_size - (rb->write_index - rb->read_index);
 
-	/* no space */
-	if (size == 0) return 0;
-	/* drop some data */
-	if (size < length) length = size;
+    /* no space */
+    if (size == 0) return 0;
+    /* drop some data */
+    if (size < length) length = size;
 
-	write_position = (rb->write_index & mask);
-	if (rb->buffer_size - write_position> length)
-	{
-		/* read_index - write_index = empty space */
-		memcpy(&rb->buffer_ptr[write_position], ptr, length);
-	}
-	else
-	{
-		memcpy(&rb->buffer_ptr[write_position], ptr, rb->buffer_size - write_position);
-		memcpy(&rb->buffer_ptr[0], &ptr[rb->buffer_size - write_position],
-				length - (rb->buffer_size - write_position));
-	}
-	rb->write_index += length;
+    write_position = (rb->write_index & mask);
+    if (rb->buffer_size - write_position> length)
+    {
+        /* read_index - write_index = empty space */
+        memcpy(&rb->buffer_ptr[write_position], ptr, length);
+    }
+    else
+    {
+        memcpy(&rb->buffer_ptr[write_position], ptr,
+               rb->buffer_size - write_position);
+        memcpy(&rb->buffer_ptr[0], &ptr[rb->buffer_size - write_position],
+               length - (rb->buffer_size - write_position));
+    }
+    rb->write_index += length;
 
-	return length;
+    return length;
 }
 RTM_EXPORT(rt_ringbuffer_put);
 
@@ -69,80 +74,82 @@ RTM_EXPORT(rt_ringbuffer_put);
  */
 rt_size_t rt_ringbuffer_putchar(struct rt_ringbuffer* rb, const rt_uint8_t ch)
 {
-	rt_uint16_t mask;
+    rt_uint16_t mask;
 
-	RT_ASSERT(rb != RT_NULL);
-	/* whether has enough space */
-	mask = rb->buffer_size - 1;
-	
-	/* whether has enough space */
-	if (rb->write_index - rb->read_index == rb->buffer_size) return 0;
+    RT_ASSERT(rb != RT_NULL);
+    /* whether has enough space */
+    mask = rb->buffer_size - 1;
+    
+    /* whether has enough space */
+    if (rb->write_index - rb->read_index == rb->buffer_size) return 0;
 
-	/* put character */
-	rb->buffer_ptr[rb->write_index & mask] = ch;
-	rb->write_index += 1;
+    /* put character */
+    rb->buffer_ptr[rb->write_index & mask] = ch;
+    rb->write_index += 1;
 
-	return 1;
+    return 1;
 }
 RTM_EXPORT(rt_ringbuffer_putchar);
 
 /**
  *  get data from ring buffer
  */
-rt_size_t rt_ringbuffer_get(struct rt_ringbuffer* rb, rt_uint8_t *ptr, rt_uint16_t length)
+rt_size_t rt_ringbuffer_get(struct rt_ringbuffer *rb,
+                            rt_uint8_t           *ptr,
+                            rt_uint16_t           length)
 {
-	rt_size_t size;
-	rt_uint16_t mask;
-	rt_uint16_t read_position;
+    rt_size_t size;
+    rt_uint16_t mask;
+    rt_uint16_t read_position;
 
-	RT_ASSERT(rb != RT_NULL);
-	/* whether has enough data  */
-	mask = rb->buffer_size - 1;
-	size = rb->write_index - rb->read_index;
+    RT_ASSERT(rb != RT_NULL);
+    /* whether has enough data  */
+    mask = rb->buffer_size - 1;
+    size = rb->write_index - rb->read_index;
 
-	/* no data */
-	if (size == 0) return 0;
-	/* less data */
-	if (size < length) length = size;
+    /* no data */
+    if (size == 0) return 0;
+    /* less data */
+    if (size < length) length = size;
 
-	read_position = rb->read_index & mask;
-	if (rb->buffer_size - read_position >= length)
-	{
-		/* copy all of data */
-		memcpy(ptr, &rb->buffer_ptr[read_position], length);
-	}
-	else
-	{
-		/* copy first and second */
-		memcpy(ptr, &rb->buffer_ptr[read_position], rb->buffer_size - read_position);
-		memcpy(&ptr[rb->buffer_size - read_position], &rb->buffer_ptr[0],
-			   length - rb->buffer_size + read_position);
-	}
-	rb->read_index += length;
+    read_position = rb->read_index & mask;
+    if (rb->buffer_size - read_position >= length)
+    {
+        /* copy all of data */
+        memcpy(ptr, &rb->buffer_ptr[read_position], length);
+    }
+    else
+    {
+        /* copy first and second */
+        memcpy(ptr, &rb->buffer_ptr[read_position],
+               rb->buffer_size - read_position);
+        memcpy(&ptr[rb->buffer_size - read_position], &rb->buffer_ptr[0],
+               length - rb->buffer_size + read_position);
+    }
+    rb->read_index += length;
 
-	return length;
+    return length;
 }
 RTM_EXPORT(rt_ringbuffer_get);
 
 /**
  * get a character from a ringbuffer
  */
-rt_size_t rt_ringbuffer_getchar(struct rt_ringbuffer* rb, rt_uint8_t *ch)
+rt_size_t rt_ringbuffer_getchar(struct rt_ringbuffer *rb, rt_uint8_t *ch)
 {
-	rt_uint16_t mask;
+    rt_uint16_t mask;
 
-	RT_ASSERT(rb != RT_NULL);
-	
-	/* ringbuffer is empty */
-	if (rb->read_index == rb->write_index) return 0;
+    RT_ASSERT(rb != RT_NULL);
+    
+    /* ringbuffer is empty */
+    if (rb->read_index == rb->write_index) return 0;
 
-	mask = rb->buffer_size - 1;
+    mask = rb->buffer_size - 1;
 
-	/* put character */
-	*ch = rb->buffer_ptr[rb->read_index & mask];
-	rb->read_index += 1;
+    /* put character */
+    *ch = rb->buffer_ptr[rb->read_index & mask];
+    rb->read_index += 1;
 
-	return 1;
+    return 1;
 }
 RTM_EXPORT(rt_ringbuffer_getchar);
-