fixed the coding style in the components/drivers

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

components/drivers/i2c/i2c_core.c

-/*
- * File      : i2c_core.c
- * This file is part of RT-Thread RTOS
- * COPYRIGHT (C) 2006, 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-04-25     weety		first version
- */
-
-#include <rtdevice.h>
-
-static struct rt_mutex i2c_core_lock;
-
-rt_err_t rt_i2c_bus_device_register(struct rt_i2c_bus_device *bus,
-                                    const char *bus_name)
-{
-    rt_err_t res = RT_EOK;
-
-    rt_mutex_init(&bus->lock, "i2c_bus_lock", RT_IPC_FLAG_FIFO);
-
-    rt_mutex_take(&i2c_core_lock, RT_WAITING_FOREVER);
-
-    if (bus->timeout == 0)
-        bus->timeout = RT_TICK_PER_SECOND;
-
-    res = rt_i2c_bus_device_device_init(bus, bus_name);
-
-    i2c_dbg("I2C bus [%s] registered\n", bus_name);
-
-    rt_mutex_release(&i2c_core_lock);
-    return res;
-}
-
-
-struct rt_i2c_bus_device* rt_i2c_bus_device_find(const char *bus_name)
-{
-    struct rt_i2c_bus_device *bus;
-    rt_device_t dev = rt_device_find(bus_name);
-    if (dev == RT_NULL || dev->type != RT_Device_Class_I2CBUS)
-    {
-        i2c_dbg("I2C bus %s not exist\n", bus_name);
-        return RT_NULL;
-    }
-
-    bus = (struct rt_i2c_bus_device *)dev->user_data;
-
-    return bus;
-}
-
-
-rt_size_t rt_i2c_transfer(struct rt_i2c_bus_device *bus,
-                          struct rt_i2c_msg msgs[],
-                          rt_uint32_t num)
-{
-    rt_size_t ret;
-
-    if (bus->ops->master_xfer)
-    {
-#ifdef RT_I2C_DEBUG
-        for (ret = 0; ret < num; ret++)
-        {
-            i2c_dbg("msgs[%d] %c, addr=0x%02x, len=%d%s\n", ret,
-                    (msgs[ret].flags & RT_I2C_RD) ? 'R' : 'W',
-                    msgs[ret].addr, msgs[ret].len);
-        }
-#endif
-
-        rt_mutex_take(&bus->lock, RT_WAITING_FOREVER);
-        ret = bus->ops->master_xfer(bus, msgs, num);
-        rt_mutex_release(&bus->lock);
-
-        return ret;
-    }
-    else
-    {
-        i2c_dbg("I2C bus operation not supported\n");
-        return 0;
-    }
-}
-
-
-rt_size_t rt_i2c_master_send(struct rt_i2c_bus_device *bus,
-                             rt_uint16_t addr,
-                             rt_uint16_t flags,
-                             const rt_uint8_t *buf,
-                             rt_uint32_t count)
-{
-    rt_size_t ret;
-    struct rt_i2c_msg msg;
-
-    msg.addr = addr;
-    msg.flags = flags & RT_I2C_ADDR_10BIT;
-    msg.len = count;
-    msg.buf = (rt_uint8_t *)buf;
-
-    ret = rt_i2c_transfer(bus, &msg, 1);
-
-    return (ret > 0) ? count : ret;
-}
-
-
-
-rt_size_t rt_i2c_master_recv(struct rt_i2c_bus_device *bus,
-                             rt_uint16_t addr,
-                             rt_uint16_t flags,
-                             rt_uint8_t *buf,
-                             rt_uint32_t count)
-{
-    rt_size_t ret;
-    struct rt_i2c_msg msg;
-    RT_ASSERT(bus != RT_NULL);
-
-    msg.addr = addr;
-    msg.flags = flags & RT_I2C_ADDR_10BIT;
-    msg.flags |= RT_I2C_RD;
-    msg.len = count;
-    msg.buf = buf;
-
-    ret = rt_i2c_transfer(bus, &msg, 1);
-
-    return (ret > 0) ? count : ret;
-}
-
-
-rt_err_t rt_i2c_core_init(void)
-{
-
-    return rt_mutex_init (&i2c_core_lock, "i2c_core_lock", RT_IPC_FLAG_FIFO);
-}
-
+/*
+ * File      : i2c_core.c
+ * This file is part of RT-Thread RTOS
+ * COPYRIGHT (C) 2006 - 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-04-25     weety         first version
+ */
+
+#include <rtdevice.h>
+
+static struct rt_mutex i2c_core_lock;
+
+rt_err_t rt_i2c_bus_device_register(struct rt_i2c_bus_device *bus,
+                                    const char               *bus_name)
+{
+    rt_err_t res = RT_EOK;
+
+    rt_mutex_init(&bus->lock, "i2c_bus_lock", RT_IPC_FLAG_FIFO);
+
+    rt_mutex_take(&i2c_core_lock, RT_WAITING_FOREVER);
+
+    if (bus->timeout == 0)
+        bus->timeout = RT_TICK_PER_SECOND;
+
+    res = rt_i2c_bus_device_device_init(bus, bus_name);
+
+    i2c_dbg("I2C bus [%s] registered\n", bus_name);
+
+    rt_mutex_release(&i2c_core_lock);
+
+    return res;
+}
+
+struct rt_i2c_bus_device *rt_i2c_bus_device_find(const char *bus_name)
+{
+    struct rt_i2c_bus_device *bus;
+    rt_device_t dev = rt_device_find(bus_name);
+    if (dev == RT_NULL || dev->type != RT_Device_Class_I2CBUS)
+    {
+        i2c_dbg("I2C bus %s not exist\n", bus_name);
+
+        return RT_NULL;
+    }
+
+    bus = (struct rt_i2c_bus_device *)dev->user_data;
+
+    return bus;
+}
+
+rt_size_t rt_i2c_transfer(struct rt_i2c_bus_device *bus,
+                          struct rt_i2c_msg         msgs[],
+                          rt_uint32_t               num)
+{
+    rt_size_t ret;
+
+    if (bus->ops->master_xfer)
+    {
+#ifdef RT_I2C_DEBUG
+        for (ret = 0; ret < num; ret++)
+        {
+            i2c_dbg("msgs[%d] %c, addr=0x%02x, len=%d%s\n", ret,
+                    (msgs[ret].flags & RT_I2C_RD) ? 'R' : 'W',
+                    msgs[ret].addr, msgs[ret].len);
+        }
+#endif
+
+        rt_mutex_take(&bus->lock, RT_WAITING_FOREVER);
+        ret = bus->ops->master_xfer(bus, msgs, num);
+        rt_mutex_release(&bus->lock);
+
+        return ret;
+    }
+    else
+    {
+        i2c_dbg("I2C bus operation not supported\n");
+
+        return 0;
+    }
+}
+
+rt_size_t rt_i2c_master_send(struct rt_i2c_bus_device *bus,
+                             rt_uint16_t               addr,
+                             rt_uint16_t               flags,
+                             const rt_uint8_t         *buf,
+                             rt_uint32_t               count)
+{
+    rt_size_t ret;
+    struct rt_i2c_msg msg;
+
+    msg.addr  = addr;
+    msg.flags = flags & RT_I2C_ADDR_10BIT;
+    msg.len   = count;
+    msg.buf   = (rt_uint8_t *)buf;
+
+    ret = rt_i2c_transfer(bus, &msg, 1);
+
+    return (ret > 0) ? count : ret;
+}
+
+rt_size_t rt_i2c_master_recv(struct rt_i2c_bus_device *bus,
+                             rt_uint16_t               addr,
+                             rt_uint16_t               flags,
+                             rt_uint8_t               *buf,
+                             rt_uint32_t               count)
+{
+    rt_size_t ret;
+    struct rt_i2c_msg msg;
+    RT_ASSERT(bus != RT_NULL);
+
+    msg.addr   = addr;
+    msg.flags  = flags & RT_I2C_ADDR_10BIT;
+    msg.flags |= RT_I2C_RD;
+    msg.len    = count;
+    msg.buf    = buf;
+
+    ret = rt_i2c_transfer(bus, &msg, 1);
+
+    return (ret > 0) ? count : ret;
+}
+
+rt_err_t rt_i2c_core_init(void)
+{
+    return rt_mutex_init(&i2c_core_lock, "i2c_core_lock", RT_IPC_FLAG_FIFO);
+}
+

components/drivers/i2c/i2c_dev.c

-#include <rtdevice.h>
-
-static rt_err_t i2c_bus_device_init(rt_device_t dev)
-{
-    struct rt_i2c_bus_device* bus = (struct rt_i2c_bus_device *)dev->user_data;
-    RT_ASSERT(bus != RT_NULL);
-
-    return RT_EOK;
-}
-
-static rt_size_t i2c_bus_device_read (rt_device_t dev,
-                                      rt_off_t pos,
-                                      void *buffer,
-                                      rt_size_t count)
-{
-    rt_uint16_t addr;
-    rt_uint16_t flags;
-    struct rt_i2c_bus_device* bus = (struct rt_i2c_bus_device *)dev->user_data;
-
-    RT_ASSERT(bus != RT_NULL);
-    RT_ASSERT(buffer != RT_NULL);
-
-    i2c_dbg("I2C bus dev [%s] reading %u bytes.\n", dev->parent.name, count);
-
-    addr = pos & 0xffff;
-    flags = (pos >> 16) & 0xffff;
-
-    return rt_i2c_master_recv(bus, addr, flags, buffer, count);
-}
-
-
-static rt_size_t i2c_bus_device_write (rt_device_t dev,
-                                       rt_off_t pos,
-                                       const void *buffer,
-                                       rt_size_t count)
-{
-    rt_uint16_t addr;
-    rt_uint16_t flags;
-    struct rt_i2c_bus_device* bus = (struct rt_i2c_bus_device *)dev->user_data;
-
-    RT_ASSERT(bus != RT_NULL);
-    RT_ASSERT(buffer != RT_NULL);
-
-    i2c_dbg("I2C bus dev writing %u bytes.\n", dev->parent.name, count);
-
-    addr = pos & 0xffff;
-    flags = (pos >> 16) & 0xffff;
-
-    return rt_i2c_master_send(bus, addr, flags, buffer, count);
-}
-
-static rt_err_t i2c_bus_device_control(rt_device_t dev,
-                                       rt_uint8_t cmd,
-                                       void *args)
-{
-    rt_err_t ret;
-    struct rt_i2c_priv_data *priv_data;
-    struct rt_i2c_bus_device* bus = (struct rt_i2c_bus_device *)dev->user_data;
-
-    RT_ASSERT(bus != RT_NULL);
-
-    switch (cmd)
-    {
-    case RT_I2C_DEV_CTRL_10BIT: /* set 10-bit addr mode */
-        bus->flags |= RT_I2C_ADDR_10BIT;
-        break;
-    case RT_I2C_DEV_CTRL_ADDR:
-        bus->addr = *(rt_uint16_t *)args;
-        break;
-    case RT_I2C_DEV_CTRL_TIMEOUT:
-        bus->timeout = *(rt_uint32_t *)args;
-        break;
-    case RT_I2C_DEV_CTRL_RW:
-        priv_data = (struct rt_i2c_priv_data *)args;
-        ret = rt_i2c_transfer(bus, priv_data->msgs, priv_data->number);
-        if (ret < 0)
-        {
-            return -RT_EIO;
-        }
-        break;
-    default:
-        break;
-    }
-
-    return RT_EOK;
-}
-
-
-rt_err_t rt_i2c_bus_device_device_init(struct rt_i2c_bus_device* bus,
-                                       const char* name)
-{
-    struct rt_device *device;
-    RT_ASSERT(bus != RT_NULL);
-
-    device = &bus->parent;
-
-    device->user_data = bus;
-
-    /* set device type */
-    device->type    = RT_Device_Class_I2CBUS;
-    /* initialize device interface */
-    device->init	= i2c_bus_device_init;
-    device->open	= RT_NULL;
-    device->close	= RT_NULL;
-    device->read	= i2c_bus_device_read;
-    device->write	= i2c_bus_device_write;
-    device->control = i2c_bus_device_control;
-
-    /* register to device manager */
-    rt_device_register(device, name, RT_DEVICE_FLAG_RDWR);
-
-    return RT_EOK;
-}
+/*
+ * File      : i2c_dev.c
+ * This file is part of RT-Thread RTOS
+ * COPYRIGHT (C) 2006 - 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-04-25     weety         first version
+ */
+
+#include <rtdevice.h>
+
+static rt_err_t i2c_bus_device_init(rt_device_t dev)
+{
+    struct rt_i2c_bus_device *bus = (struct rt_i2c_bus_device *)dev->user_data;
+    RT_ASSERT(bus != RT_NULL);
+
+    return RT_EOK;
+}
+
+static rt_size_t i2c_bus_device_read(rt_device_t dev,
+                                     rt_off_t    pos,
+                                     void       *buffer,
+                                     rt_size_t   count)
+{
+    rt_uint16_t addr;
+    rt_uint16_t flags;
+    struct rt_i2c_bus_device *bus = (struct rt_i2c_bus_device *)dev->user_data;
+
+    RT_ASSERT(bus != RT_NULL);
+    RT_ASSERT(buffer != RT_NULL);
+
+    i2c_dbg("I2C bus dev [%s] reading %u bytes.\n", dev->parent.name, count);
+
+    addr = pos & 0xffff;
+    flags = (pos >> 16) & 0xffff;
+
+    return rt_i2c_master_recv(bus, addr, flags, buffer, count);
+}
+
+static rt_size_t i2c_bus_device_write(rt_device_t dev,
+                                      rt_off_t    pos,
+                                      const void *buffer,
+                                      rt_size_t   count)
+{
+    rt_uint16_t addr;
+    rt_uint16_t flags;
+    struct rt_i2c_bus_device *bus = (struct rt_i2c_bus_device *)dev->user_data;
+
+    RT_ASSERT(bus != RT_NULL);
+    RT_ASSERT(buffer != RT_NULL);
+
+    i2c_dbg("I2C bus dev writing %u bytes.\n", dev->parent.name, count);
+
+    addr = pos & 0xffff;
+    flags = (pos >> 16) & 0xffff;
+
+    return rt_i2c_master_send(bus, addr, flags, buffer, count);
+}
+
+static rt_err_t i2c_bus_device_control(rt_device_t dev,
+                                       rt_uint8_t  cmd,
+                                       void       *args)
+{
+    rt_err_t ret;
+    struct rt_i2c_priv_data *priv_data;
+    struct rt_i2c_bus_device *bus = (struct rt_i2c_bus_device *)dev->user_data;
+
+    RT_ASSERT(bus != RT_NULL);
+
+    switch (cmd)
+    {
+    /* set 10-bit addr mode */
+    case RT_I2C_DEV_CTRL_10BIT:
+        bus->flags |= RT_I2C_ADDR_10BIT;
+        break;
+    case RT_I2C_DEV_CTRL_ADDR:
+        bus->addr = *(rt_uint16_t *)args;
+        break;
+    case RT_I2C_DEV_CTRL_TIMEOUT:
+        bus->timeout = *(rt_uint32_t *)args;
+        break;
+    case RT_I2C_DEV_CTRL_RW:
+        priv_data = (struct rt_i2c_priv_data *)args;
+        ret = rt_i2c_transfer(bus, priv_data->msgs, priv_data->number);
+        if (ret < 0)
+        {
+            return -RT_EIO;
+        }
+        break;
+    default:
+        break;
+    }
+
+    return RT_EOK;
+}
+
+rt_err_t rt_i2c_bus_device_device_init(struct rt_i2c_bus_device *bus,
+                                       const char               *name)
+{
+    struct rt_device *device;
+    RT_ASSERT(bus != RT_NULL);
+
+    device = &bus->parent;
+
+    device->user_data = bus;
+
+    /* set device type */
+    device->type    = RT_Device_Class_I2CBUS;
+    /* initialize device interface */
+    device->init    = i2c_bus_device_init;
+    device->open    = RT_NULL;
+    device->close   = RT_NULL;
+    device->read    = i2c_bus_device_read;
+    device->write   = i2c_bus_device_write;
+    device->control = i2c_bus_device_control;
+
+    /* register to device manager */
+    rt_device_register(device, name, RT_DEVICE_FLAG_RDWR);
+
+    return RT_EOK;
+}

components/drivers/include/drivers/i2c-bit-ops.h

-/*
- * File      : i2c-bit-ops.h
- * This file is part of RT-Thread RTOS
- * COPYRIGHT (C) 2006, 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-04-25     weety		first version
- */
-
-#ifndef __I2C_BIT_OPS_H__
-#define __I2C_BIT_OPS_H__
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-struct rt_i2c_bit_ops
-{
-    void *data;  /* private data for lowlevel routines */
-    void (*set_sda) (void *data, rt_int32_t state);
-    void (*set_scl) (void *data, rt_int32_t state);
-    rt_int32_t  (*get_sda) (void *data);
-    rt_int32_t  (*get_scl) (void *data);
-
-    void (*udelay) (rt_uint32_t us);
-
-    rt_uint32_t delay_us;  /* scl and sda line delay */
-    rt_uint32_t timeout;  /* in tick */
-};
-
-rt_err_t rt_i2c_bit_add_bus(struct rt_i2c_bus_device *bus,
-                            const char *bus_name);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif
+/*
+ * File      : i2c-bit-ops.h
+ * This file is part of RT-Thread RTOS
+ * COPYRIGHT (C) 2006 - 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-04-25     weety         first version
+ */
+
+#ifndef __I2C_BIT_OPS_H__
+#define __I2C_BIT_OPS_H__
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct rt_i2c_bit_ops
+{
+    void *data;            /* private data for lowlevel routines */
+    void (*set_sda)(void *data, rt_int32_t state);
+    void (*set_scl)(void *data, rt_int32_t state);
+    rt_int32_t (*get_sda)(void *data);
+    rt_int32_t (*get_scl)(void *data);
+
+    void (*udelay)(rt_uint32_t us);
+
+    rt_uint32_t delay_us;  /* scl and sda line delay */
+    rt_uint32_t timeout;   /* in tick */
+};
+
+rt_err_t rt_i2c_bit_add_bus(struct rt_i2c_bus_device *bus,
+                            const char               *bus_name);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

components/drivers/include/drivers/i2c.h

-/*
- * File      : i2c.h
- * This file is part of RT-Thread RTOS
- * COPYRIGHT (C) 2006, 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-04-25     weety		first version
- */
-
-#ifndef __I2C_H__
-#define __I2C_H__
-
-#include <rtthread.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#define RT_I2C_WR                0x0000
-#define RT_I2C_RD               (1u << 0)
-#define RT_I2C_ADDR_10BIT       (1u << 2)  /* this is a ten bit chip address */
-#define RT_I2C_NO_START         (1u << 4)
-#define RT_I2C_IGNORE_NACK      (1u << 5)
-#define RT_I2C_NO_READ_ACK      (1u << 6)  /* when I2C reading, we do not ACK */
-
-struct rt_i2c_msg
-{
-    rt_uint16_t addr;
-    rt_uint16_t flags;
-    rt_uint16_t len;
-    rt_uint8_t  *buf;
-};
-
-struct rt_i2c_bus_device;
-
-struct rt_i2c_bus_device_ops
-{
-    rt_size_t (*master_xfer) (struct rt_i2c_bus_device *bus,
-                              struct rt_i2c_msg msgs[],
-                              rt_uint32_t num);
-    rt_size_t (*slave_xfer) (struct rt_i2c_bus_device *bus,
-                             struct rt_i2c_msg msgs[],
-                             rt_uint32_t num);
-    rt_err_t (*i2c_bus_control) (struct rt_i2c_bus_device *bus,
-                                 rt_uint32_t,
-                                 rt_uint32_t);
-};
-
-/*for i2c bus driver*/
-struct rt_i2c_bus_device
-{
-    struct rt_device parent;
-    const struct rt_i2c_bus_device_ops *ops;
-    rt_uint16_t  flags;
-    rt_uint16_t  addr;
-    struct rt_mutex lock;
-    rt_uint32_t  timeout;
-    rt_uint32_t  retries;
-    void *priv;
-};
-
-#ifdef RT_I2C_DEBUG
-#define i2c_dbg(fmt, ...)	rt_kprintf(fmt, ##__VA_ARGS__)
-#else
-#define i2c_dbg(fmt, ...)
-#endif
-
-rt_err_t rt_i2c_bus_device_register(struct rt_i2c_bus_device *bus,
-                                    const char *bus_name);
-struct rt_i2c_bus_device* rt_i2c_bus_device_find(const char *bus_name);
-rt_size_t rt_i2c_transfer(struct rt_i2c_bus_device *bus,
-                          struct rt_i2c_msg msgs[],
-                          rt_uint32_t num);
-rt_size_t rt_i2c_master_send(struct rt_i2c_bus_device *bus,
-                             rt_uint16_t addr,
-                             rt_uint16_t flags,
-                             const rt_uint8_t *buf,
-                             rt_uint32_t count);
-rt_size_t rt_i2c_master_recv(struct rt_i2c_bus_device *bus,
-                             rt_uint16_t addr,
-                             rt_uint16_t flags,
-                             rt_uint8_t *buf,
-                             rt_uint32_t count);
-rt_err_t rt_i2c_core_init(void);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif
+/*
+ * File      : i2c.h
+ * This file is part of RT-Thread RTOS
+ * COPYRIGHT (C) 2006 - 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-04-25     weety         first version
+ */
+
+#ifndef __I2C_H__
+#define __I2C_H__
+
+#include <rtthread.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define RT_I2C_WR                0x0000
+#define RT_I2C_RD               (1u << 0)
+#define RT_I2C_ADDR_10BIT       (1u << 2)  /* this is a ten bit chip address */
+#define RT_I2C_NO_START         (1u << 4)
+#define RT_I2C_IGNORE_NACK      (1u << 5)
+#define RT_I2C_NO_READ_ACK      (1u << 6)  /* when I2C reading, we do not ACK */
+
+struct rt_i2c_msg
+{
+    rt_uint16_t addr;
+    rt_uint16_t flags;
+    rt_uint16_t len;
+    rt_uint8_t  *buf;
+};
+
+struct rt_i2c_bus_device;
+
+struct rt_i2c_bus_device_ops
+{
+    rt_size_t (*master_xfer)(struct rt_i2c_bus_device *bus,
+                             struct rt_i2c_msg msgs[],
+                             rt_uint32_t num);
+    rt_size_t (*slave_xfer)(struct rt_i2c_bus_device *bus,
+                            struct rt_i2c_msg msgs[],
+                            rt_uint32_t num);
+    rt_err_t (*i2c_bus_control)(struct rt_i2c_bus_device *bus,
+                                rt_uint32_t,
+                                rt_uint32_t);
+};
+
+/*for i2c bus driver*/
+struct rt_i2c_bus_device
+{
+    struct rt_device parent;
+    const struct rt_i2c_bus_device_ops *ops;
+    rt_uint16_t  flags;
+    rt_uint16_t  addr;
+    struct rt_mutex lock;
+    rt_uint32_t  timeout;
+    rt_uint32_t  retries;
+    void *priv;
+};
+
+#ifdef RT_I2C_DEBUG
+#define i2c_dbg(fmt, ...)   rt_kprintf(fmt, ##__VA_ARGS__)
+#else
+#define i2c_dbg(fmt, ...)
+#endif
+
+rt_err_t rt_i2c_bus_device_register(struct rt_i2c_bus_device *bus,
+                                    const char               *bus_name);
+struct rt_i2c_bus_device *rt_i2c_bus_device_find(const char *bus_name);
+rt_size_t rt_i2c_transfer(struct rt_i2c_bus_device *bus,
+                          struct rt_i2c_msg         msgs[],
+                          rt_uint32_t               num);
+rt_size_t rt_i2c_master_send(struct rt_i2c_bus_device *bus,
+                             rt_uint16_t               addr,
+                             rt_uint16_t               flags,
+                             const rt_uint8_t         *buf,
+                             rt_uint32_t               count);
+rt_size_t rt_i2c_master_recv(struct rt_i2c_bus_device *bus,
+                             rt_uint16_t               addr,
+                             rt_uint16_t               flags,
+                             rt_uint8_t               *buf,
+                             rt_uint32_t               count);
+rt_err_t rt_i2c_core_init(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

components/drivers/include/drivers/i2c_dev.h

-#ifndef __I2C_DEV_H__
-#define __I2C_DEV_H__
-
-#include <rtthread.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#define RT_I2C_DEV_CTRL_10BIT        0x20
-#define RT_I2C_DEV_CTRL_ADDR         0x21
-#define RT_I2C_DEV_CTRL_TIMEOUT      0x22
-#define RT_I2C_DEV_CTRL_RW           0x23
-
-struct rt_i2c_priv_data
-{
-    struct rt_i2c_msg  *msgs;
-    rt_size_t  number;
-};
-
-rt_err_t rt_i2c_bus_device_device_init(struct rt_i2c_bus_device* bus,
-                                       const char* name);
-
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif
+/*
+ * File      : i2c_dev.h
+ * This file is part of RT-Thread RTOS
+ * COPYRIGHT (C) 2006 - 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-04-25     weety         first version
+ */
+
+#ifndef __I2C_DEV_H__
+#define __I2C_DEV_H__
+
+#include <rtthread.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define RT_I2C_DEV_CTRL_10BIT        0x20
+#define RT_I2C_DEV_CTRL_ADDR         0x21
+#define RT_I2C_DEV_CTRL_TIMEOUT      0x22
+#define RT_I2C_DEV_CTRL_RW           0x23
+
+struct rt_i2c_priv_data
+{
+    struct rt_i2c_msg  *msgs;
+    rt_size_t  number;
+};
+
+rt_err_t rt_i2c_bus_device_device_init(struct rt_i2c_bus_device *bus,
+                                       const char               *name);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

components/drivers/mtd/mtd_nand.c

-/*
- * File      : mtd_core.c
- * This file is part of RT-Thread RTOS
- * COPYRIGHT (C) 2006 - 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
- * 2011-12-05     Bernard      the first version
- */
-
-/*
- * COPYRIGHT (C) 2012, Shanghai Real Thread
- */
-
-#include <drivers/mtd_nand.h>
-
-#ifdef RT_USING_MTD_NAND
-
-/*
- * RT-Thread Generic Device Interface
- */
-static rt_err_t _mtd_init(rt_device_t dev)
-{
-	return RT_EOK;
-}
-
-static rt_err_t _mtd_open(rt_device_t dev, rt_uint16_t oflag)
-{
-	return RT_EOK;
-}
-
-static rt_err_t _mtd_close(rt_device_t dev)
-{
-	return RT_EOK;
-}
-
-static rt_size_t _mtd_read(rt_device_t dev, rt_off_t pos, void *buffer, rt_size_t size)
-{
-	return size;
-}
-
-static rt_size_t _mtd_write(rt_device_t dev, rt_off_t pos, const void *buffer, rt_size_t size)
-{
-	return size;
-}
-
-static rt_err_t _mtd_control(rt_device_t dev, rt_uint8_t cmd, void *args)
-{
-	return RT_EOK;
-}
-
-rt_err_t rt_mtd_nand_register_device(const char* name, struct rt_mtd_nand_device* device)
-{
-	rt_device_t dev;
-
-	dev = RT_DEVICE(device);
-	RT_ASSERT(dev != RT_NULL);
-
-	/* set device class and generic device interface */
-	dev->type 		= RT_Device_Class_MTD;
-	dev->init 		= _mtd_init;
-	dev->open 		= _mtd_open;
-	dev->read 		= _mtd_read;
-	dev->write 		= _mtd_write;
-	dev->close      = _mtd_close;
-	dev->control 	= _mtd_control;
-
-	dev->rx_indicate = RT_NULL;
-	dev->tx_complete = RT_NULL;
-
-	/* register to RT-Thread device system */
-	return rt_device_register(dev, name, RT_DEVICE_FLAG_RDWR | RT_DEVICE_FLAG_STANDALONE);
+/*
+ * File      : mtd_core.c
+ * This file is part of RT-Thread RTOS
+ * COPYRIGHT (C) 2006 - 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
+ * 2011-12-05     Bernard      the first version
+ */
+
+/*
+ * COPYRIGHT (C) 2012, Shanghai Real Thread
+ */
+
+#include <drivers/mtd_nand.h>
+
+#ifdef RT_USING_MTD_NAND
+
+/**
+ * RT-Thread Generic Device Interface
+ */
+static rt_err_t _mtd_init(rt_device_t dev)
+{
+    return RT_EOK;
 }
-#endif
+
+static rt_err_t _mtd_open(rt_device_t dev, rt_uint16_t oflag)
+{
+    return RT_EOK;
+}
+
+static rt_err_t _mtd_close(rt_device_t dev)
+{
+    return RT_EOK;
+}
+
+static rt_size_t _mtd_read(rt_device_t dev,
+                           rt_off_t    pos,
+                           void       *buffer,
+                           rt_size_t   size)
+{
+    return size;
+}
+
+static rt_size_t _mtd_write(rt_device_t dev,
+                            rt_off_t    pos,
+                            const void *buffer,
+                            rt_size_t   size)
+{
+    return size;
+}
+
+static rt_err_t _mtd_control(rt_device_t dev, rt_uint8_t cmd, void *args)
+{
+    return RT_EOK;
+}
+
+rt_err_t rt_mtd_nand_register_device(const char                *name,
+                                     struct rt_mtd_nand_device *device)
+{
+    rt_device_t dev;
+
+    dev = RT_DEVICE(device);
+    RT_ASSERT(dev != RT_NULL);
+
+    /* set device class and generic device interface */
+    dev->type        = RT_Device_Class_MTD;
+    dev->init        = _mtd_init;
+    dev->open        = _mtd_open;
+    dev->read        = _mtd_read;
+    dev->write       = _mtd_write;
+    dev->close       = _mtd_close;
+    dev->control     = _mtd_control;
+
+    dev->rx_indicate = RT_NULL;
+    dev->tx_complete = RT_NULL;
+
+    /* register to RT-Thread device system */
+    return rt_device_register(dev, name, RT_DEVICE_FLAG_RDWR | RT_DEVICE_FLAG_STANDALONE);
+}
+
+
+#endif

components/drivers/mtd/mtd_nor.c

-/*
- * File      : mtd_nor.c
- * This file is part of RT-Thread RTOS
- * COPYRIGHT (C) 2012, Shanghai Real-Thread Technology Co., Ltd
- *
- * 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-5-30     Bernard      the first version
- */
-
-#include <drivers/mtd_nor.h>
-
-#ifdef RT_USING_MTD_NOR
-
-/*
- * RT-Thread Generic Device Interface
- */
-static rt_err_t _mtd_init(rt_device_t dev)
-{
-	return RT_EOK;
-}
-
-static rt_err_t _mtd_open(rt_device_t dev, rt_uint16_t oflag)
-{
-	return RT_EOK;
-}
-
-static rt_err_t _mtd_close(rt_device_t dev)
-{
-	return RT_EOK;
-}
-
-static rt_size_t _mtd_read(rt_device_t dev, rt_off_t pos, void *buffer, rt_size_t size)
-{
-	return size;
-}
-
-static rt_size_t _mtd_write(rt_device_t dev, rt_off_t pos, const void *buffer, rt_size_t size)
-{
-	return size;
-}
-
-static rt_err_t _mtd_control(rt_device_t dev, rt_uint8_t cmd, void *args)
-{
-	return RT_EOK;
-}
-
-rt_err_t rt_mtd_nor_register_device(const char* name, struct rt_mtd_nor_device* device)
-{
-	rt_device_t dev;
-
-	dev = RT_DEVICE(device);
-	RT_ASSERT(dev != RT_NULL);
-
-	/* set device class and generic device interface */
-	dev->type 		= RT_Device_Class_MTD;
-	dev->init 		= _mtd_init;
-	dev->open 		= _mtd_open;
-	dev->read 		= _mtd_read;
-	dev->write 		= _mtd_write;
-	dev->close      = _mtd_close;
-	dev->control 	= _mtd_control;
-
-	dev->rx_indicate = RT_NULL;
-	dev->tx_complete = RT_NULL;
-
-	/* register to RT-Thread device system */
-	return rt_device_register(dev, name, RT_DEVICE_FLAG_RDWR | RT_DEVICE_FLAG_STANDALONE);
-}
-#endif
+/*
+ * File      : mtd_nor.c
+ * This file is part of RT-Thread RTOS
+ * COPYRIGHT (C) 2012, Shanghai Real-Thread Technology Co., Ltd
+ *
+ * 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-5-30     Bernard      the first version
+ */
+
+#include <drivers/mtd_nor.h>
+
+#ifdef RT_USING_MTD_NOR
+
+/**
+ * RT-Thread Generic Device Interface
+ */
+static rt_err_t _mtd_init(rt_device_t dev)
+{
+    return RT_EOK;
+}
+
+static rt_err_t _mtd_open(rt_device_t dev, rt_uint16_t oflag)
+{
+    return RT_EOK;
+}
+
+static rt_err_t _mtd_close(rt_device_t dev)
+{
+    return RT_EOK;
+}
+
+static rt_size_t _mtd_read(rt_device_t dev,
+                           rt_off_t    pos,
+                           void       *buffer,
+                           rt_size_t   size)
+{
+    return size;
+}
+
+static rt_size_t _mtd_write(rt_device_t dev,
+                            rt_off_t    pos,
+                            const void *buffer,
+                            rt_size_t   size)
+{
+    return size;
+}
+
+static rt_err_t _mtd_control(rt_device_t dev, rt_uint8_t cmd, void *args)
+{
+    return RT_EOK;
+}
+
+rt_err_t rt_mtd_nor_register_device(const char               *name,
+                                    struct rt_mtd_nor_device *device)
+{
+    rt_device_t dev;
+
+    dev = RT_DEVICE(device);
+    RT_ASSERT(dev != RT_NULL);
+
+    /* set device class and generic device interface */
+    dev->type        = RT_Device_Class_MTD;
+    dev->init        = _mtd_init;
+    dev->open        = _mtd_open;
+    dev->read        = _mtd_read;
+    dev->write       = _mtd_write;
+    dev->close       = _mtd_close;
+    dev->control     = _mtd_control;
+
+    dev->rx_indicate = RT_NULL;
+    dev->tx_complete = RT_NULL;
+
+    /* register to RT-Thread device system */
+    return rt_device_register(dev, name, RT_DEVICE_FLAG_RDWR | RT_DEVICE_FLAG_STANDALONE);
+}
+
+#endif

components/drivers/src/completion.c

@@ -89,6 +89,7 @@ rt_err_t rt_completion_wait(struct rt_completion *completion,
 
 __exit:
     rt_hw_interrupt_enable(level);
+
     return result;
 }
 

components/drivers/src/pipe.c

-/*
- * File      : pipe.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 <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)
-{
-    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);
-
-    thread = rt_thread_self();
-
-    /* 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);
-
-            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);
-
-                rt_schedule();
-            }
-            else
-            {
-                rt_hw_interrupt_enable(level);
-            }
-            break;
-        }
-    } while (read_nbytes == 0);
-
-    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)
-{
-    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;
-
-    thread = rt_thread_self();
-
-    /* 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);
-
-            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);
-
-                rt_schedule();
-            }
-            else
-            {
-                rt_hw_interrupt_enable(level);
-            }
-            break;
-        }
-    }while (write_nbytes == 0);
-
-    return write_nbytes;
-}
-
-static rt_err_t rt_pipe_control(rt_device_t dev, rt_uint8_t cmd, void *args)
-{
-    return RT_EOK;
-}
-
-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;
-
-    /* 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;
-
-        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);
-
-    return result;
-}
-RTM_EXPORT(rt_pipe_create);
-
-void rt_pipe_destroy(struct rt_pipe_device *pipe)
-{
-    if (pipe == RT_NULL)
-        return;
-
-    /* un-register pipe device */
-    rt_device_unregister(&(pipe->parent));
-
-    /* release memory */
-    rt_free(pipe->ringbuffer.buffer_ptr);
-    rt_free(pipe);
-
-    return;
-}
-RTM_EXPORT(rt_pipe_destroy);
+/*
+ * File      : pipe.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 <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)
+{
+    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);
+
+    thread = rt_thread_self();
+
+    /* 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);
+
+            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);
+
+                rt_schedule();
+            }
+            else
+            {
+                rt_hw_interrupt_enable(level);
+            }
+            break;
+        }
+    } while (read_nbytes == 0);
+
+    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)
+{
+    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;
+
+    thread = rt_thread_self();
+
+    /* 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);
+
+            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);
+
+                rt_schedule();
+            }
+            else
+            {
+                rt_hw_interrupt_enable(level);
+            }
+            break;
+        }
+    }while (write_nbytes == 0);
+
+    return write_nbytes;
+}
+
+static rt_err_t rt_pipe_control(rt_device_t dev, rt_uint8_t cmd, void *args)
+{
+    return RT_EOK;
+}
+
+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;
+
+    /* 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;
+
+        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);
+
+    return result;
+}
+RTM_EXPORT(rt_pipe_create);
+
+void rt_pipe_destroy(struct rt_pipe_device *pipe)
+{
+    if (pipe == RT_NULL)
+        return;
+
+    /* un-register pipe device */
+    rt_device_unregister(&(pipe->parent));
+
+    /* release memory */
+    rt_free(pipe->ringbuffer.buffer_ptr);
+    rt_free(pipe);
+
+    return;
+}
+RTM_EXPORT(rt_pipe_destroy);

components/drivers/src/ringbuffer.c

-/*
- * File      : ringbuffer.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 <string.h>
-
-void rt_ringbuffer_init(struct rt_ringbuffer *rb,
-                        rt_uint8_t           *pool,
-                        rt_uint16_t           size)
-{
-    RT_ASSERT(rb != RT_NULL);
-
-    /* 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);
-}
-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_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);
-
-    /* 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;
-
-    return length;
-}
-RTM_EXPORT(rt_ringbuffer_put);
-
-/**
- * put a character into ring buffer
- */
-rt_size_t rt_ringbuffer_putchar(struct rt_ringbuffer* rb, const rt_uint8_t ch)
-{
-    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;
-
-    /* put character */
-    rb->buffer_ptr[rb->write_index & mask] = ch;
-    rb->write_index += 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 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;
-
-    /* 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;
-
-    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_uint16_t mask;
-
-    RT_ASSERT(rb != RT_NULL);
-    
-    /* ringbuffer is empty */
-    if (rb->read_index == rb->write_index) return 0;
-
-    mask = rb->buffer_size - 1;
-
-    /* put character */
-    *ch = rb->buffer_ptr[rb->read_index & mask];
-    rb->read_index += 1;
-
-    return 1;
-}
-RTM_EXPORT(rt_ringbuffer_getchar);
+/*
+ * File      : ringbuffer.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 <string.h>
+
+void rt_ringbuffer_init(struct rt_ringbuffer *rb,
+                        rt_uint8_t           *pool,
+                        rt_uint16_t           size)
+{
+    RT_ASSERT(rb != RT_NULL);
+
+    /* 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);
+}
+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_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);
+
+    /* 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;
+
+    return length;
+}
+RTM_EXPORT(rt_ringbuffer_put);
+
+/**
+ * put a character into ring buffer
+ */
+rt_size_t rt_ringbuffer_putchar(struct rt_ringbuffer *rb, const rt_uint8_t ch)
+{
+    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;
+
+    /* put character */
+    rb->buffer_ptr[rb->write_index & mask] = ch;
+    rb->write_index += 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 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;
+
+    /* 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;
+
+    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_uint16_t mask;
+
+    RT_ASSERT(rb != RT_NULL);
+    
+    /* ringbuffer is empty */
+    if (rb->read_index == rb->write_index)
+        return 0;
+
+    mask = rb->buffer_size - 1;
+
+    /* put character */
+    *ch = rb->buffer_ptr[rb->read_index & mask];
+    rb->read_index += 1;
+
+    return 1;
+}
+RTM_EXPORT(rt_ringbuffer_getchar);