diff --git a/src/mempool.c b/src/mempool.c
index 69adee612c246ac50ac7feab6ea01a7a1c7f24d4..7c3a5103259e23fda88af2075276376abac60096 100644
--- a/src/mempool.c
+++ b/src/mempool.c
@@ -43,7 +43,7 @@ static void (*rt_mp_free_hook)(struct rt_mempool *mp, void *block);
  */
 void rt_mp_alloc_sethook(void (*hook)(struct rt_mempool *mp, void *block))
 {
-	rt_mp_alloc_hook = hook;
+    rt_mp_alloc_hook = hook;
 }
 
 /**
@@ -54,7 +54,7 @@ void rt_mp_alloc_sethook(void (*hook)(struct rt_mempool *mp, void *block))
  */
 void rt_mp_free_sethook(void (*hook)(struct rt_mempool *mp, void *block))
 {
-	rt_mp_free_hook = hook;
+    rt_mp_free_hook = hook;
 }
 
 /*@}*/
@@ -67,8 +67,8 @@ void rt_mp_free_sethook(void (*hook)(struct rt_mempool *mp, void *block))
 /*@{*/
 
 /**
- * This function will initialize a memory pool object, normally which is used for
- * static object.
+ * This function will initialize a memory pool object, normally which is used
+ * for static object.
  *
  * @param mp the memory pool object
  * @param name the name of memory pool
@@ -78,46 +78,51 @@ void rt_mp_free_sethook(void (*hook)(struct rt_mempool *mp, void *block))
  *
  * @return RT_EOK
  */
-rt_err_t rt_mp_init(struct rt_mempool *mp, const char *name, void *start, rt_size_t size, rt_size_t block_size)
+rt_err_t rt_mp_init(struct rt_mempool *mp,
+                    const char        *name,
+                    void              *start,
+                    rt_size_t          size,
+                    rt_size_t          block_size)
 {
-	rt_uint8_t *block_ptr;
-	register rt_base_t offset;
+    rt_uint8_t *block_ptr;
+    register rt_base_t offset;
 
-	/* parameter check */
-	RT_ASSERT(mp != RT_NULL);
+    /* parameter check */
+    RT_ASSERT(mp != RT_NULL);
 
-	/* initialize object */
-	rt_object_init(&(mp->parent), RT_Object_Class_MemPool, name);
+    /* initialize object */
+    rt_object_init(&(mp->parent), RT_Object_Class_MemPool, name);
 
-	/* initialize memory pool */
-	mp->start_address = start;
-	mp->size = RT_ALIGN_DOWN(size, RT_ALIGN_SIZE);
+    /* initialize memory pool */
+    mp->start_address = start;
+    mp->size = RT_ALIGN_DOWN(size, RT_ALIGN_SIZE);
 
-	/* align the block size */
-	block_size = RT_ALIGN(block_size, RT_ALIGN_SIZE);
-	mp->block_size = block_size;
+    /* align the block size */
+    block_size = RT_ALIGN(block_size, RT_ALIGN_SIZE);
+    mp->block_size = block_size;
 
-	/* align to align size byte */
-	mp->block_total_count = mp->size / (mp->block_size + sizeof(rt_uint8_t *));
-	mp->block_free_count = mp->block_total_count;
+    /* align to align size byte */
+    mp->block_total_count = mp->size / (mp->block_size + sizeof(rt_uint8_t *));
+    mp->block_free_count  = mp->block_total_count;
 
-	/* initialize suspended thread list */
-	rt_list_init(&(mp->suspend_thread));
-	mp->suspend_thread_count = 0;
+    /* initialize suspended thread list */
+    rt_list_init(&(mp->suspend_thread));
+    mp->suspend_thread_count = 0;
 
-	/* initialize free block list */
-	block_ptr = (rt_uint8_t *)mp->start_address;
-	for (offset = 0; offset < mp->block_total_count; offset ++)
-	{
-		*(rt_uint8_t **)(block_ptr + offset * (block_size + sizeof(rt_uint8_t *)))
-			= (rt_uint8_t *)(block_ptr + (offset + 1) * (block_size + sizeof(rt_uint8_t *)));
-	}
+    /* initialize free block list */
+    block_ptr = (rt_uint8_t *)mp->start_address;
+    for (offset = 0; offset < mp->block_total_count; offset ++)
+    {
+        *(rt_uint8_t **)(block_ptr + offset * (block_size + sizeof(rt_uint8_t *))) =
+            (rt_uint8_t *)(block_ptr + (offset + 1) * (block_size + sizeof(rt_uint8_t *)));
+    }
 
-	*(rt_uint8_t **)(block_ptr + (offset - 1) * (block_size + sizeof(rt_uint8_t *))) = RT_NULL;
+    *(rt_uint8_t **)(block_ptr + (offset - 1) * (block_size + sizeof(rt_uint8_t *))) =
+        RT_NULL;
 
-	mp->block_list = block_ptr;
+    mp->block_list = block_ptr;
 
-	return RT_EOK;
+    return RT_EOK;
 }
 RTM_EXPORT(rt_mp_init);
 
@@ -130,47 +135,48 @@ RTM_EXPORT(rt_mp_init);
  */
 rt_err_t rt_mp_detach(struct rt_mempool *mp)
 {
-	struct rt_thread *thread;
-	register rt_ubase_t temp;
+    struct rt_thread *thread;
+    register rt_ubase_t temp;
 
-	/* parameter check */
-	RT_ASSERT(mp != RT_NULL);
+    /* parameter check */
+    RT_ASSERT(mp != RT_NULL);
 
-	/* wake up all suspended threads */
-	while (!rt_list_isempty(&(mp->suspend_thread)))
-	{
-		/* disable interrupt */
-		temp = rt_hw_interrupt_disable();
+    /* wake up all suspended threads */
+    while (!rt_list_isempty(&(mp->suspend_thread)))
+    {
+        /* disable interrupt */
+        temp = rt_hw_interrupt_disable();
 
-		/* get next suspend thread */
-		thread = rt_list_entry(mp->suspend_thread.next, struct rt_thread, tlist);
-		/* set error code to RT_ERROR */
-		thread->error = -RT_ERROR;
+        /* get next suspend thread */
+        thread = rt_list_entry(mp->suspend_thread.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);
+        /*
+         * resume thread
+         * In rt_thread_resume function, it will remove current thread from
+         * suspend list
+         */
+        rt_thread_resume(thread);
 
-		/* decrease suspended thread count */
-		mp->suspend_thread_count --;
+        /* decrease suspended thread count */
+        mp->suspend_thread_count --;
 
-		/* enable interrupt */
-		rt_hw_interrupt_enable(temp);
-	}
+        /* enable interrupt */
+        rt_hw_interrupt_enable(temp);
+    }
 
-	/* detach object */
-	rt_object_detach(&(mp->parent));
+    /* detach object */
+    rt_object_detach(&(mp->parent));
 
-	return RT_EOK;
+    return RT_EOK;
 }
 RTM_EXPORT(rt_mp_detach);
 
 #ifdef RT_USING_HEAP
 /**
- * This function will create a mempool object and allocate the memory pool from heap.
+ * This function will create a mempool object and allocate the memory pool from
+ * heap.
  *
  * @param name the name of memory pool
  * @param block_count the count of blocks in memory pool
@@ -178,54 +184,59 @@ RTM_EXPORT(rt_mp_detach);
  *
  * @return the created mempool object
  */
-rt_mp_t rt_mp_create(const char *name, rt_size_t block_count, rt_size_t block_size)
+rt_mp_t rt_mp_create(const char *name,
+                     rt_size_t   block_count,
+                     rt_size_t   block_size)
 {
-	rt_uint8_t *block_ptr;
-	struct rt_mempool *mp;
-	register rt_base_t offset;
-
-	RT_DEBUG_NOT_IN_INTERRUPT;
-
-	/* allocate object */
-	mp = (struct rt_mempool *)rt_object_allocate(RT_Object_Class_MemPool, name);
-	if (mp == RT_NULL)
-		return RT_NULL; /* allocate object failed */
-
-	/* initialize memory pool */
-	block_size = RT_ALIGN(block_size, RT_ALIGN_SIZE);
-	mp->block_size = block_size;
-	mp->size = (block_size + sizeof(rt_uint8_t *)) * block_count;
-
-	/* allocate memory */
-	mp->start_address = rt_malloc((block_size + sizeof(rt_uint8_t *)) * block_count);
-	if (mp->start_address == RT_NULL)
-	{
-		/* no memory, delete memory pool object */
-		rt_object_delete(&(mp->parent));
-
-		return RT_NULL;
-	}
-
-	mp->block_total_count = block_count;
-	mp->block_free_count = mp->block_total_count;
-
-	/* initialize suspended thread list */
-	rt_list_init(&(mp->suspend_thread));
-	mp->suspend_thread_count = 0;
-
-	/* initialize free block list */
-	block_ptr = (rt_uint8_t *)mp->start_address;
-	for (offset = 0; offset < mp->block_total_count; offset ++)
-	{
-		*(rt_uint8_t **)(block_ptr + offset * (block_size + sizeof(rt_uint8_t *)))
-			= block_ptr + (offset + 1) * (block_size + sizeof(rt_uint8_t *));
-	}
-
-	*(rt_uint8_t **)(block_ptr + (offset - 1) * (block_size + sizeof(rt_uint8_t *))) = RT_NULL;
-
-	mp->block_list = block_ptr;
-
-	return mp;
+    rt_uint8_t *block_ptr;
+    struct rt_mempool *mp;
+    register rt_base_t offset;
+
+    RT_DEBUG_NOT_IN_INTERRUPT;
+
+    /* allocate object */
+    mp = (struct rt_mempool *)rt_object_allocate(RT_Object_Class_MemPool, name);
+    /* allocate object failed */
+    if (mp == RT_NULL)
+        return RT_NULL;
+
+    /* initialize memory pool */
+    block_size     = RT_ALIGN(block_size, RT_ALIGN_SIZE);
+    mp->block_size = block_size;
+    mp->size       = (block_size + sizeof(rt_uint8_t *)) * block_count;
+
+    /* allocate memory */
+    mp->start_address = rt_malloc((block_size + sizeof(rt_uint8_t *)) *
+                                  block_count);
+    if (mp->start_address == RT_NULL)
+    {
+        /* no memory, delete memory pool object */
+        rt_object_delete(&(mp->parent));
+
+        return RT_NULL;
+    }
+
+    mp->block_total_count = block_count;
+    mp->block_free_count  = mp->block_total_count;
+
+    /* initialize suspended thread list */
+    rt_list_init(&(mp->suspend_thread));
+    mp->suspend_thread_count = 0;
+
+    /* initialize free block list */
+    block_ptr = (rt_uint8_t *)mp->start_address;
+    for (offset = 0; offset < mp->block_total_count; offset ++)
+    {
+        *(rt_uint8_t **)(block_ptr + offset * (block_size + sizeof(rt_uint8_t *)))
+            = block_ptr + (offset + 1) * (block_size + sizeof(rt_uint8_t *));
+    }
+
+    *(rt_uint8_t **)(block_ptr + (offset - 1) * (block_size + sizeof(rt_uint8_t *)))
+        = RT_NULL;
+
+    mp->block_list = block_ptr;
+
+    return mp;
 }
 RTM_EXPORT(rt_mp_create);
 
@@ -238,53 +249,53 @@ RTM_EXPORT(rt_mp_create);
  */
 rt_err_t rt_mp_delete(rt_mp_t mp)
 {
-	struct rt_thread *thread;
-	register rt_ubase_t temp;
+    struct rt_thread *thread;
+    register rt_ubase_t temp;
 
-	RT_DEBUG_NOT_IN_INTERRUPT;
+    RT_DEBUG_NOT_IN_INTERRUPT;
 
-	/* parameter check */
-	RT_ASSERT(mp != RT_NULL);
+    /* parameter check */
+    RT_ASSERT(mp != RT_NULL);
 
-	/* wake up all suspended threads */
-	while (!rt_list_isempty(&(mp->suspend_thread)))
-	{
-		/* disable interrupt */
-		temp = rt_hw_interrupt_disable();
+    /* wake up all suspended threads */
+    while (!rt_list_isempty(&(mp->suspend_thread)))
+    {
+        /* disable interrupt */
+        temp = rt_hw_interrupt_disable();
 
-		/* get next suspend thread */
-		thread = rt_list_entry(mp->suspend_thread.next, struct rt_thread, tlist);
-		/* set error code to RT_ERROR */
-		thread->error = -RT_ERROR;
+        /* get next suspend thread */
+        thread = rt_list_entry(mp->suspend_thread.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);
+        /*
+         * resume thread
+         * In rt_thread_resume function, it will remove current thread from
+         * suspend list
+         */
+        rt_thread_resume(thread);
 
-		/* decrease suspended thread count */
-		mp->suspend_thread_count --;
+        /* decrease suspended thread count */
+        mp->suspend_thread_count --;
 
-		/* enable interrupt */
-		rt_hw_interrupt_enable(temp);
-	}
+        /* enable interrupt */
+        rt_hw_interrupt_enable(temp);
+    }
 
 #if defined(RT_USING_MODULE) && defined(RT_USING_SLAB)
-	/* the mp object belongs to an application module */
-	if (mp->parent.flag & RT_OBJECT_FLAG_MODULE) 
-		rt_module_free(mp->parent.module_id, mp->start_address);
-	else
+    /* the mp object belongs to an application module */
+    if (mp->parent.flag & RT_OBJECT_FLAG_MODULE) 
+        rt_module_free(mp->parent.module_id, mp->start_address);
+    else
 #endif
 
-	/* release allocated room */
-	rt_free(mp->start_address);
+    /* release allocated room */
+    rt_free(mp->start_address);
 
-	/* detach object */
-	rt_object_delete(&(mp->parent));
+    /* detach object */
+    rt_object_delete(&(mp->parent));
 
-	return RT_EOK;
+    return RT_EOK;
 }
 RTM_EXPORT(rt_mp_delete);
 #endif
@@ -299,83 +310,87 @@ RTM_EXPORT(rt_mp_delete);
  */
 void *rt_mp_alloc(rt_mp_t mp, rt_int32_t time)
 {
-	rt_uint8_t *block_ptr;
-	register rt_base_t level;
-	struct rt_thread *thread;
-
-	/* disable interrupt */
-	level = rt_hw_interrupt_disable();
-
-	if (mp->block_free_count)
-	{
-		/* memory block is available. decrease the free block counter */
-		mp->block_free_count --;
-
-		/* get block from block list */
-		block_ptr = mp->block_list;
-		mp->block_list = *(rt_uint8_t **)block_ptr;
-
-		/* point to memory pool */
-		*(rt_uint8_t **)block_ptr = (rt_uint8_t *)mp;
-	}
-	else
-	{
-		/* memory block is unavailable. */
-		if (time == 0)
-		{
-			/* enable interrupt */
-			rt_hw_interrupt_enable(level);
-			return RT_NULL;
-		}
-		else
-		{
-			RT_DEBUG_NOT_IN_INTERRUPT;
-
-			/* get current thread */
-			thread = rt_thread_self();
-
-			/* need suspend thread */
-			rt_thread_suspend(thread);
-			rt_list_insert_after(&(mp->suspend_thread), &(thread->tlist));
-			mp->suspend_thread_count ++;
-
-			if (time > 0)
-			{
-				/* init thread timer and start it */
-				rt_timer_control(&(thread->thread_timer), RT_TIMER_CTRL_SET_TIME, &time);
-				rt_timer_start(&(thread->thread_timer));
-			}
-
-			/* enable interrupt */
-			rt_hw_interrupt_enable(level);
-
-			/* do a schedule */
-			rt_schedule();
-
-			if (thread->error != RT_EOK)
-				return RT_NULL;
-
-			/* disable interrupt */
-			level = rt_hw_interrupt_disable();
-
-			/* decrease free block */
-			mp->block_free_count --;
-
-			/* get block from block list */
-			block_ptr = mp->block_list;
-			mp->block_list = *(rt_uint8_t **)block_ptr;
-
-			/* point to memory pool */
-			*(rt_uint8_t **)block_ptr = (rt_uint8_t *)mp;
-		}
-	}
-
-	/* enable interrupt */
-	rt_hw_interrupt_enable(level);
-
-	RT_OBJECT_HOOK_CALL(rt_mp_alloc_hook, (mp, (rt_uint8_t *)(block_ptr + sizeof(rt_uint8_t *))));
-
-	return (rt_uint8_t *)(block_ptr + sizeof(rt_uint8_t *));
+    rt_uint8_t *block_ptr;
+    register rt_base_t level;
+    struct rt_thread *thread;
+
+    /* disable interrupt */
+    level = rt_hw_interrupt_disable();
+
+    if (mp->block_free_count)
+    {
+        /* memory block is available. decrease the free block counter */
+        mp->block_free_count --;
+
+        /* get block from block list */
+        block_ptr      = mp->block_list;
+        mp->block_list = *(rt_uint8_t **)block_ptr;
+
+        /* point to memory pool */
+        *(rt_uint8_t **)block_ptr = (rt_uint8_t *)mp;
+    }
+    else
+    {
+        /* memory block is unavailable. */
+        if (time == 0)
+        {
+            /* enable interrupt */
+            rt_hw_interrupt_enable(level);
+
+            return RT_NULL;
+        }
+        else
+        {
+            RT_DEBUG_NOT_IN_INTERRUPT;
+
+            /* get current thread */
+            thread = rt_thread_self();
+
+            /* need suspend thread */
+            rt_thread_suspend(thread);
+            rt_list_insert_after(&(mp->suspend_thread), &(thread->tlist));
+            mp->suspend_thread_count ++;
+
+            if (time > 0)
+            {
+                /* init thread timer and start it */
+                rt_timer_control(&(thread->thread_timer),
+                                 RT_TIMER_CTRL_SET_TIME,
+                                 &time);
+                rt_timer_start(&(thread->thread_timer));
+            }
+
+            /* enable interrupt */
+            rt_hw_interrupt_enable(level);
+
+            /* do a schedule */
+            rt_schedule();
+
+            if (thread->error != RT_EOK)
+                return RT_NULL;
+
+            /* disable interrupt */
+            level = rt_hw_interrupt_disable();
+
+            /* decrease free block */
+            mp->block_free_count --;
+
+            /* get block from block list */
+            block_ptr      = mp->block_list;
+            mp->block_list = *(rt_uint8_t **)block_ptr;
+
+            /* point to memory pool */
+            *(rt_uint8_t **)block_ptr = (rt_uint8_t *)mp;
+        }
+    }
+
+    /* enable interrupt */
+    rt_hw_interrupt_enable(level);
+
+    RT_OBJECT_HOOK_CALL(rt_mp_alloc_hook,
+                        (mp, (rt_uint8_t *)(block_ptr + sizeof(rt_uint8_t *))));
+
+    return (rt_uint8_t *)(block_ptr + sizeof(rt_uint8_t *));
 }
 RTM_EXPORT(rt_mp_alloc);
 
@@ -386,52 +401,54 @@ RTM_EXPORT(rt_mp_alloc);
  */
 void rt_mp_free(void *block)
 {
-	rt_uint8_t **block_ptr;
-	struct rt_mempool *mp;
-	struct rt_thread *thread;
-	register rt_base_t level;
+    rt_uint8_t **block_ptr;
+    struct rt_mempool *mp;
+    struct rt_thread *thread;
+    register rt_base_t level;
 
-	/* get the control block of pool which the block belongs to */
-	block_ptr = (rt_uint8_t **)((rt_uint8_t *)block - sizeof(rt_uint8_t *));
-	mp = (struct rt_mempool *)*block_ptr;
+    /* get the control block of pool which the block belongs to */
+    block_ptr = (rt_uint8_t **)((rt_uint8_t *)block - sizeof(rt_uint8_t *));
+    mp        = (struct rt_mempool *)*block_ptr;
 
-	RT_OBJECT_HOOK_CALL(rt_mp_free_hook, (mp, block));
+    RT_OBJECT_HOOK_CALL(rt_mp_free_hook, (mp, block));
 
-	/* disable interrupt */
-	level = rt_hw_interrupt_disable();
+    /* disable interrupt */
+    level = rt_hw_interrupt_disable();
 
-	/* increase the free block count */
-	mp->block_free_count ++;
+    /* increase the free block count */
+    mp->block_free_count ++;
 
-	/* link the block into the block list */
-	*block_ptr = mp->block_list;
-	mp->block_list = (rt_uint8_t *)block_ptr;
+    /* link the block into the block list */
+    *block_ptr = mp->block_list;
+    mp->block_list = (rt_uint8_t *)block_ptr;
 
-	if (mp->suspend_thread_count > 0)
-	{
-		/* get the suspended thread */
-		thread = rt_list_entry(mp->suspend_thread.next, struct rt_thread, tlist);
+    if (mp->suspend_thread_count > 0)
+    {
+        /* get the suspended thread */
+        thread = rt_list_entry(mp->suspend_thread.next,
+                               struct rt_thread,
+                               tlist);
 
-		/* set error */
-		thread->error = RT_EOK;
+        /* set error */
+        thread->error = RT_EOK;
 
-		/* resume thread */
-		rt_thread_resume(thread);
+        /* resume thread */
+        rt_thread_resume(thread);
 
-		/* decrease suspended thread count */
-		mp->suspend_thread_count --;
+        /* decrease suspended thread count */
+        mp->suspend_thread_count --;
 
-		/* enable interrupt */
-		rt_hw_interrupt_enable(level);
+        /* enable interrupt */
+        rt_hw_interrupt_enable(level);
 
-		/* do a schedule */
-		rt_schedule();
+        /* do a schedule */
+        rt_schedule();
 
-		return;
-	}
+        return;
+    }
 
-	/* enable interrupt */
-	rt_hw_interrupt_enable(level);
+    /* enable interrupt */
+    rt_hw_interrupt_enable(level);
 }
 RTM_EXPORT(rt_mp_free);