fixed the coding style in components/drivers/src

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

4 files changed, 371 insertions, 342 deletions

diff --git a/components/drivers/src/completion.c b/components/drivers/src/completion.c
index de3101375d..8fd52e1bba 100644
--- a/components/drivers/src/completion.c
+++ b/components/drivers/src/completion.c
@@ -60,7 +60,8 @@ rt_err_t rt_completion_wait(struct rt_completion *completion,
             /* suspend thread */
             rt_thread_suspend(thread);
             /* add to suspended list */
-            rt_list_insert_before(&(completion->suspended_list), &(thread->tlist));
+            rt_list_insert_before(&(completion->suspended_list),
+                                  &(thread->tlist));
 
             /* current context checking */
             RT_DEBUG_NOT_IN_INTERRUPT;
@@ -69,7 +70,9 @@ rt_err_t rt_completion_wait(struct rt_completion *completion,
             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_control(&(thread->thread_timer),
+                                 RT_TIMER_CTRL_SET_TIME,
+                                 &timeout);
                 rt_timer_start(&(thread->thread_timer));
             }
             /* enable interrupt */
@@ -110,8 +113,10 @@ void rt_completion_done(struct rt_completion *completion)
         struct rt_thread *thread;
 
         /* get thread entry */
-        thread = rt_list_entry(completion->suspended_list.next, struct rt_thread, tlist);
-        
+        thread = rt_list_entry(completion->suspended_list.next,
+                               struct rt_thread,
+                               tlist);
+
         /* resume it */
         rt_thread_resume(thread);
         rt_hw_interrupt_enable(level);
diff --git a/components/drivers/src/dataqueue.c b/components/drivers/src/dataqueue.c
index d96addeafb..5910e1010c 100644
--- a/components/drivers/src/dataqueue.c
+++ b/components/drivers/src/dataqueue.c
@@ -1,327 +1,343 @@
-/*

- * File      : dataqueue.c

- * This file is part of RT-Thread RTOS

- * COPYRIGHT (C) 2012, RT-Thread Development Team

- *

- * The license and distribution terms for this file may be

- * found in the file LICENSE in this distribution or at

- * http://www.rt-thread.org/license/LICENSE

- *

- * Change Logs:

- * Date           Author       Notes

- * 2012-09-30     Bernard      first version.

- */

-

-#include <rtthread.h>

-#include <rtdevice.h>

-#include <rthw.h>

-

-struct rt_data_item

-{

-    const void *data_ptr;

-    rt_size_t data_size;

-};

-

-rt_err_t

-rt_data_queue_init(struct rt_data_queue *queue,

-                   rt_uint16_t size,

-                   rt_uint16_t lwm,

-                   void (*evt_notify)(struct rt_data_queue *queue, rt_uint32_t event))

-{

-    RT_ASSERT(queue != RT_NULL);

-

-    queue->evt_notify = evt_notify;

-

-    queue->size = size;

-    queue->lwm = lwm;

-    queue->waiting_lwm = RT_FALSE;

-

-    queue->get_index = 0;

-    queue->put_index = 0;

-

-    rt_list_init(&(queue->suspended_push_list));

-    rt_list_init(&(queue->suspended_pop_list));

-

-    queue->queue = (struct rt_data_item *)rt_malloc(sizeof(struct rt_data_item) * size);

-    if (queue->queue == RT_NULL)

-    {

-        return -RT_ENOMEM;

-    }

-

-    return RT_EOK;

-}

-RTM_EXPORT(rt_data_queue_init);

-

-rt_err_t rt_data_queue_push(struct rt_data_queue *queue,

-                            const void *data_ptr,

-                            rt_size_t data_size,

-                            rt_int32_t timeout)

-{

-    rt_uint16_t mask;

-    rt_ubase_t  level;

-    rt_thread_t thread;

-    rt_err_t    result;

-    

-    RT_ASSERT(queue != RT_NULL);

-

-    result = RT_EOK;

-    thread = rt_thread_self();

-    mask = queue->size - 1;

-

-    level = rt_hw_interrupt_disable();

-    while (queue->put_index - queue->get_index == queue->size)

-    {

-        queue->waiting_lwm = RT_TRUE;

-

-        /* queue is full */

-        if (timeout == 0)

-        {

-            result = -RT_ETIMEOUT;

-

-            goto __exit;

-        }

-

-        /* current context checking */

-        RT_DEBUG_NOT_IN_INTERRUPT;

-

-        /* reset thread error number */

-        thread->error = RT_EOK;

-        

-        /* suspend thread on the push list */

-        rt_thread_suspend(thread);

-        rt_list_insert_before(&(queue->suspended_push_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);

-

-        /* do schedule */

-        rt_schedule();

-

-        /* thread is waked up */

-        result = thread->error;

-        level = rt_hw_interrupt_disable();

-        if (result != RT_EOK) goto __exit;

-    }

-

-    queue->queue[queue->put_index & mask].data_ptr  = data_ptr;

-    queue->queue[queue->put_index & mask].data_size = data_size;

-    queue->put_index += 1;

-

-    if (!rt_list_isempty(&(queue->suspended_pop_list)))

-    {

-        /* there is at least one thread in suspended list */

-

-        /* get thread entry */

-        thread = rt_list_entry(queue->suspended_pop_list.next, struct rt_thread, tlist);

-

-        /* resume it */

-        rt_thread_resume(thread);

-        rt_hw_interrupt_enable(level);

-

-        /* perform a schedule */

-        rt_schedule();

-

-        return result;

-    }

-

-__exit:

-    rt_hw_interrupt_enable(level);

-    if ((result == RT_EOK) && queue->evt_notify != RT_NULL)

-    {

-        queue->evt_notify(queue, RT_DATAQUEUE_EVENT_PUSH);

-    }

-

-    return result;

-}

-RTM_EXPORT(rt_data_queue_push);

-

-rt_err_t rt_data_queue_pop(struct rt_data_queue *queue,

-                           const void** data_ptr,

-                           rt_size_t *size, 

-                           rt_int32_t timeout)

-{

-    rt_ubase_t  level;

-    rt_thread_t thread;

-    rt_err_t    result;

-    rt_uint16_t mask;

-

-    RT_ASSERT(queue != RT_NULL);

-    RT_ASSERT(data_ptr != RT_NULL);

-    RT_ASSERT(size != RT_NULL);

-

-    result = RT_EOK;

-    thread = rt_thread_self();

-    mask = queue->size - 1;

-

-    level = rt_hw_interrupt_disable();

-    while (queue->get_index == queue->put_index)

-    {

-        /* queue is empty */

-        if (timeout == 0)

-        {

-            result = -RT_ETIMEOUT;

-            goto __exit;

-        }

-

-        /* current context checking */

-        RT_DEBUG_NOT_IN_INTERRUPT;

-

-        /* reset thread error number */

-        thread->error = RT_EOK;

-        

-        /* suspend thread on the pop list */

-        rt_thread_suspend(thread);

-        rt_list_insert_before(&(queue->suspended_pop_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);

-

-        /* do schedule */

-        rt_schedule();

-

-        /* thread is waked up */

-        result = thread->error;

-        level = rt_hw_interrupt_disable();

-        if (result != RT_EOK) goto __exit;

-    }

-

-    *data_ptr = queue->queue[queue->get_index & mask].data_ptr;

-    *size     = queue->queue[queue->get_index & mask].data_size;

-

-    queue->get_index += 1;

-

-    if ((queue->waiting_lwm == RT_TRUE) && 

-        (queue->put_index - queue->get_index) <= queue->lwm)

-    {

-        queue->waiting_lwm = RT_FALSE;

-

-        /* there is at least one thread in suspended list and less than low water mark */

-        if (!rt_list_isempty(&(queue->suspended_push_list)))

-        {

-            /* get thread entry */

-            thread = rt_list_entry(queue->suspended_push_list.next, struct rt_thread, tlist);

-

-            /* resume it */

-            rt_thread_resume(thread);

-            rt_hw_interrupt_enable(level);

-

-            /* perform a schedule */

-            rt_schedule();

-        }

-

-        if (queue->evt_notify != RT_NULL)

-            queue->evt_notify(queue, RT_DATAQUEUE_EVENT_LWM);

-

-        return result;

-    }

-

-__exit:

-    rt_hw_interrupt_enable(level);

-    if ((result == RT_EOK) && (queue->evt_notify != RT_NULL))

-    {

-        queue->evt_notify(queue, RT_DATAQUEUE_EVENT_POP);

-    }

-

-    return result;

-}

-RTM_EXPORT(rt_data_queue_pop);

-

-rt_err_t rt_data_queue_peak(struct rt_data_queue *queue,

-                            const void** data_ptr,

-                            rt_size_t *size)

-{

-    rt_ubase_t  level;

-    rt_uint16_t mask;

-

-    RT_ASSERT(queue != RT_NULL);

-

-    mask = queue->size - 1;

-

-    level = rt_hw_interrupt_disable();

-

-    if (queue->get_index == queue->put_index) 

-    {

-        rt_hw_interrupt_enable(level);

-        

-        return -RT_EEMPTY;

-    }

-

-    *data_ptr = queue->queue[queue->get_index & mask].data_ptr;

-    *size     = queue->queue[queue->get_index & mask].data_size;

-

-    rt_hw_interrupt_enable(level);

-

-    return RT_EOK;

-}

-RTM_EXPORT(rt_data_queue_peak);

-

-void rt_data_queue_reset(struct rt_data_queue *queue)

-{

-    struct rt_thread *thread;

-    register rt_ubase_t temp;

-

-    rt_enter_critical();

-    /* wakeup all suspend threads */

-

-    /* resume on pop list */

-    while (!rt_list_isempty(&(queue->suspended_pop_list)))

-    {

-        /* disable interrupt */

-        temp = rt_hw_interrupt_disable();

-

-        /* get next suspend thread */

-        thread = rt_list_entry(queue->suspended_pop_list.next, struct rt_thread, tlist);

-        /* set error code to RT_ERROR */

-        thread->error = -RT_ERROR;

-

-        /*

-         * resume thread

-         * In rt_thread_resume function, it will remove current thread from

-         * suspend list

-         */

-        rt_thread_resume(thread);

-

-        /* enable interrupt */

-        rt_hw_interrupt_enable(temp);

-    }

-

-    /* resume on push list */

-    while (!rt_list_isempty(&(queue->suspended_push_list)))

-    {

-        /* disable interrupt */

-        temp = rt_hw_interrupt_disable();

-

-        /* get next suspend thread */

-        thread = rt_list_entry(queue->suspended_push_list.next, struct rt_thread, tlist);

-        /* set error code to RT_ERROR */

-        thread->error = -RT_ERROR;

-

-        /*

-         * resume thread

-         * In rt_thread_resume function, it will remove current thread from

-         * suspend list

-         */

-        rt_thread_resume(thread);

-

-        /* enable interrupt */

-        rt_hw_interrupt_enable(temp);

-    }

-    rt_exit_critical();

-

-    rt_schedule();

-}

-RTM_EXPORT(rt_data_queue_reset);

+/*
+ * File      : dataqueue.c
+ * This file is part of RT-Thread RTOS
+ * COPYRIGHT (C) 2012, RT-Thread Development Team
+ *
+ * The license and distribution terms for this file may be
+ * found in the file LICENSE in this distribution or at
+ * http://www.rt-thread.org/license/LICENSE
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ * 2012-09-30     Bernard      first version.
+ */
+
+#include <rtthread.h>
+#include <rtdevice.h>
+#include <rthw.h>
+
+struct rt_data_item
+{
+    const void *data_ptr;
+    rt_size_t data_size;
+};
+
+rt_err_t
+rt_data_queue_init(struct rt_data_queue *queue,
+                   rt_uint16_t size,
+                   rt_uint16_t lwm,
+                   void (*evt_notify)(struct rt_data_queue *queue, rt_uint32_t event))
+{
+    RT_ASSERT(queue != RT_NULL);
+
+    queue->evt_notify = evt_notify;
+
+    queue->size = size;
+    queue->lwm = lwm;
+    queue->waiting_lwm = RT_FALSE;
+
+    queue->get_index = 0;
+    queue->put_index = 0;
+
+    rt_list_init(&(queue->suspended_push_list));
+    rt_list_init(&(queue->suspended_pop_list));
+
+    queue->queue = (struct rt_data_item *)rt_malloc(sizeof(struct rt_data_item) * size);
+    if (queue->queue == RT_NULL)
+    {
+        return -RT_ENOMEM;
+    }
+
+    return RT_EOK;
+}
+RTM_EXPORT(rt_data_queue_init);
+
+rt_err_t rt_data_queue_push(struct rt_data_queue *queue,
+                            const void *data_ptr,
+                            rt_size_t data_size,
+                            rt_int32_t timeout)
+{
+    rt_uint16_t mask;
+    rt_ubase_t  level;
+    rt_thread_t thread;
+    rt_err_t    result;
+    
+    RT_ASSERT(queue != RT_NULL);
+
+    result = RT_EOK;
+    thread = rt_thread_self();
+    mask = queue->size - 1;
+
+    level = rt_hw_interrupt_disable();
+    while (queue->put_index - queue->get_index == queue->size)
+    {
+        queue->waiting_lwm = RT_TRUE;
+
+        /* queue is full */
+        if (timeout == 0)
+        {
+            result = -RT_ETIMEOUT;
+
+            goto __exit;
+        }
+
+        /* current context checking */
+        RT_DEBUG_NOT_IN_INTERRUPT;
+
+        /* reset thread error number */
+        thread->error = RT_EOK;
+        
+        /* suspend thread on the push list */
+        rt_thread_suspend(thread);
+        rt_list_insert_before(&(queue->suspended_push_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);
+
+        /* do schedule */
+        rt_schedule();
+
+        /* thread is waked up */
+        result = thread->error;
+        level = rt_hw_interrupt_disable();
+        if (result != RT_EOK) goto __exit;
+    }
+
+    queue->queue[queue->put_index & mask].data_ptr  = data_ptr;
+    queue->queue[queue->put_index & mask].data_size = data_size;
+    queue->put_index += 1;
+
+    if (!rt_list_isempty(&(queue->suspended_pop_list)))
+    {
+        /* there is at least one thread in suspended list */
+
+        /* get thread entry */
+        thread = rt_list_entry(queue->suspended_pop_list.next,
+                               struct rt_thread,
+                               tlist);
+
+        /* resume it */
+        rt_thread_resume(thread);
+        rt_hw_interrupt_enable(level);
+
+        /* perform a schedule */
+        rt_schedule();
+
+        return result;
+    }
+
+__exit:
+    rt_hw_interrupt_enable(level);
+    if ((result == RT_EOK) && queue->evt_notify != RT_NULL)
+    {
+        queue->evt_notify(queue, RT_DATAQUEUE_EVENT_PUSH);
+    }
+
+    return result;
+}
+RTM_EXPORT(rt_data_queue_push);
+
+rt_err_t rt_data_queue_pop(struct rt_data_queue *queue,
+                           const void** data_ptr,
+                           rt_size_t *size, 
+                           rt_int32_t timeout)
+{
+    rt_ubase_t  level;
+    rt_thread_t thread;
+    rt_err_t    result;
+    rt_uint16_t mask;
+
+    RT_ASSERT(queue != RT_NULL);
+    RT_ASSERT(data_ptr != RT_NULL);
+    RT_ASSERT(size != RT_NULL);
+
+    result = RT_EOK;
+    thread = rt_thread_self();
+    mask   = queue->size - 1;
+
+    level = rt_hw_interrupt_disable();
+    while (queue->get_index == queue->put_index)
+    {
+        /* queue is empty */
+        if (timeout == 0)
+        {
+            result = -RT_ETIMEOUT;
+            goto __exit;
+        }
+
+        /* current context checking */
+        RT_DEBUG_NOT_IN_INTERRUPT;
+
+        /* reset thread error number */
+        thread->error = RT_EOK;
+        
+        /* suspend thread on the pop list */
+        rt_thread_suspend(thread);
+        rt_list_insert_before(&(queue->suspended_pop_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);
+
+        /* do schedule */
+        rt_schedule();
+
+        /* thread is waked up */
+        result = thread->error;
+        level  = rt_hw_interrupt_disable();
+        if (result != RT_EOK)
+            goto __exit;
+    }
+
+    *data_ptr = queue->queue[queue->get_index & mask].data_ptr;
+    *size     = queue->queue[queue->get_index & mask].data_size;
+
+    queue->get_index += 1;
+
+    if ((queue->waiting_lwm == RT_TRUE) && 
+        (queue->put_index - queue->get_index) <= queue->lwm)
+    {
+        queue->waiting_lwm = RT_FALSE;
+
+        /*
+         * there is at least one thread in suspended list
+         * and less than low water mark
+         */
+        if (!rt_list_isempty(&(queue->suspended_push_list)))
+        {
+            /* get thread entry */
+            thread = rt_list_entry(queue->suspended_push_list.next,
+                                   struct rt_thread,
+                                   tlist);
+
+            /* resume it */
+            rt_thread_resume(thread);
+            rt_hw_interrupt_enable(level);
+
+            /* perform a schedule */
+            rt_schedule();
+        }
+
+        if (queue->evt_notify != RT_NULL)
+            queue->evt_notify(queue, RT_DATAQUEUE_EVENT_LWM);
+
+        return result;
+    }
+
+__exit:
+    rt_hw_interrupt_enable(level);
+    if ((result == RT_EOK) && (queue->evt_notify != RT_NULL))
+    {
+        queue->evt_notify(queue, RT_DATAQUEUE_EVENT_POP);
+    }
+
+    return result;
+}
+RTM_EXPORT(rt_data_queue_pop);
+
+rt_err_t rt_data_queue_peak(struct rt_data_queue *queue,
+                            const void** data_ptr,
+                            rt_size_t *size)
+{
+    rt_ubase_t  level;
+    rt_uint16_t mask;
+
+    RT_ASSERT(queue != RT_NULL);
+
+    mask = queue->size - 1;
+
+    level = rt_hw_interrupt_disable();
+
+    if (queue->get_index == queue->put_index) 
+    {
+        rt_hw_interrupt_enable(level);
+        
+        return -RT_EEMPTY;
+    }
+
+    *data_ptr = queue->queue[queue->get_index & mask].data_ptr;
+    *size     = queue->queue[queue->get_index & mask].data_size;
+
+    rt_hw_interrupt_enable(level);
+
+    return RT_EOK;
+}
+RTM_EXPORT(rt_data_queue_peak);
+
+void rt_data_queue_reset(struct rt_data_queue *queue)
+{
+    struct rt_thread *thread;
+    register rt_ubase_t temp;
+
+    rt_enter_critical();
+    /* wakeup all suspend threads */
+
+    /* resume on pop list */
+    while (!rt_list_isempty(&(queue->suspended_pop_list)))
+    {
+        /* disable interrupt */
+        temp = rt_hw_interrupt_disable();
+
+        /* get next suspend thread */
+        thread = rt_list_entry(queue->suspended_pop_list.next,
+                               struct rt_thread,
+                               tlist);
+        /* set error code to RT_ERROR */
+        thread->error = -RT_ERROR;
+
+        /*
+         * resume thread
+         * In rt_thread_resume function, it will remove current thread from
+         * suspend list
+         */
+        rt_thread_resume(thread);
+
+        /* enable interrupt */
+        rt_hw_interrupt_enable(temp);
+    }
+
+    /* resume on push list */
+    while (!rt_list_isempty(&(queue->suspended_push_list)))
+    {
+        /* disable interrupt */
+        temp = rt_hw_interrupt_disable();
+
+        /* get next suspend thread */
+        thread = rt_list_entry(queue->suspended_push_list.next,
+                               struct rt_thread,
+                               tlist);
+        /* set error code to RT_ERROR */
+        thread->error = -RT_ERROR;
+
+        /*
+         * resume thread
+         * In rt_thread_resume function, it will remove current thread from
+         * suspend list
+         */
+        rt_thread_resume(thread);
+
+        /* enable interrupt */
+        rt_hw_interrupt_enable(temp);
+    }
+    rt_exit_critical();
+
+    rt_schedule();
+}
+RTM_EXPORT(rt_data_queue_reset);
diff --git a/components/drivers/src/pipe.c b/components/drivers/src/pipe.c
index a0ea434ba3..0d2027a83a 100644
--- a/components/drivers/src/pipe.c
+++ b/components/drivers/src/pipe.c
@@ -42,7 +42,8 @@ static rt_size_t rt_pipe_read(rt_device_t dev,
         {
             rt_thread_suspend(thread);
             /* waiting on suspended read list */
-            rt_list_insert_before(&(pipe->suspended_read_list), &(thread->tlist));
+            rt_list_insert_before(&(pipe->suspended_read_list),
+                                  &(thread->tlist));
             rt_hw_interrupt_enable(level);
 
             rt_schedule();
@@ -52,8 +53,9 @@ static rt_size_t rt_pipe_read(rt_device_t dev,
             if (!rt_list_isempty(&pipe->suspended_write_list))
             {
                 /* get suspended thread */
-                thread = rt_list_entry(pipe->suspended_write_list.next, 
-                    struct rt_thread, tlist);
+                thread = rt_list_entry(pipe->suspended_write_list.next,
+                                       struct rt_thread,
+                                       tlist);
 
                 /* resume the write thread */
                 rt_thread_resume(thread);
@@ -102,7 +104,8 @@ static rt_size_t rt_pipe_write(rt_device_t dev,
             /* 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_list_insert_before(&(pipe->suspended_write_list),
+                                  &(thread->tlist));
             rt_hw_interrupt_enable(level);
 
             rt_schedule();
@@ -113,7 +116,8 @@ static rt_size_t rt_pipe_write(rt_device_t dev,
             {
                 /* get suspended thread */
                 thread = rt_list_entry(pipe->suspended_read_list.next,
-                                       struct rt_thread, tlist);
+                                       struct rt_thread,
+                                       tlist);
 
                 /* resume the read thread */
                 rt_thread_resume(thread);
@@ -158,7 +162,7 @@ rt_err_t rt_pipe_create(const char *name, rt_size_t size)
         /* 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);
 
diff --git a/components/drivers/src/ringbuffer.c b/components/drivers/src/ringbuffer.c
index 6454fd9932..6ef8f5da63 100644
--- a/components/drivers/src/ringbuffer.c
+++ b/components/drivers/src/ringbuffer.c
@@ -38,7 +38,7 @@ rt_size_t rt_ringbuffer_put(struct rt_ringbuffer *rb,
     rt_uint16_t size;
     rt_uint16_t mask;
     rt_uint16_t write_position;
-    
+
     RT_ASSERT(rb != RT_NULL);
 
     mask = rb->buffer_size - 1;
@@ -60,9 +60,11 @@ rt_size_t rt_ringbuffer_put(struct rt_ringbuffer *rb,
     }
     else
     {
-        memcpy(&rb->buffer_ptr[write_position], ptr,
+        memcpy(&rb->buffer_ptr[write_position],
+               ptr,
                rb->buffer_size - write_position);
-        memcpy(&rb->buffer_ptr[0], &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;
@@ -126,9 +128,11 @@ rt_size_t rt_ringbuffer_get(struct rt_ringbuffer *rb,
     else
     {
         /* copy first and second */
-        memcpy(ptr, &rb->buffer_ptr[read_position],
+        memcpy(ptr,
+               &rb->buffer_ptr[read_position],
                rb->buffer_size - read_position);
-        memcpy(&ptr[rb->buffer_size - read_position], &rb->buffer_ptr[0],
+        memcpy(&ptr[rb->buffer_size - read_position],
+               &rb->buffer_ptr[0],
                length - rb->buffer_size + read_position);
     }
     rb->read_index += length;