fixed a eclipse compiling warning.

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

7 files changed, 914 insertions, 871 deletions

diff --git a/components/drivers/i2c/i2c-bit-ops.c b/components/drivers/i2c/i2c-bit-ops.c
index 9fcbc9e9bb..bfd4512f1e 100644
--- a/components/drivers/i2c/i2c-bit-ops.c
+++ b/components/drivers/i2c/i2c-bit-ops.c
@@ -1,444 +1,444 @@
-/*
- * File      : i2c-bit-ops.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>
-
-#ifdef RT_I2C_BIT_DEBUG
-#define bit_dbg(fmt, ...)	rt_kprintf(fmt, ##__VA_ARGS__)
-#else
-#define bit_dbg(fmt, ...)
-#endif
-
-
-#define SET_SDA(ops, val)	ops->set_sda(ops->data, val)
-#define SET_SCL(ops, val)	ops->set_scl(ops->data, val)
-#define GET_SDA(ops)		ops->get_sda(ops->data)
-#define GET_SCL(ops)		ops->get_scl(ops->data)
-
-rt_inline void i2c_delay(struct rt_i2c_bit_ops *ops)
-{
-	ops->udelay((ops->delay_us + 1) >> 1);
-}
-
-rt_inline void i2c_delay2(struct rt_i2c_bit_ops *ops)
-{
-	ops->udelay(ops->delay_us);
-}
-
-#define SDA_L(ops)	SET_SDA(ops, 0)
-#define SDA_H(ops)	SET_SDA(ops, 1)
-#define SCL_L(ops)	SET_SCL(ops, 0)
-
-/*
- * release scl line, and wait scl line to high.
- */
-static rt_err_t SCL_H(struct rt_i2c_bit_ops *ops)
-{
-	rt_tick_t start;
-
-	SET_SCL(ops, 1);
-
-	if (!ops->get_scl)
-		goto done;
-
-	start = rt_tick_get();
-	while (!GET_SCL(ops))
-	{
-		if ((rt_tick_get() - start) > ops->timeout)
-			return -RT_ETIMEOUT;
-		rt_thread_delay((ops->timeout + 1) >> 1);
-	}
-#ifdef RT_I2C_BIT_DEBUG
-	if (rt_tick_get() != start)
-	{
-		bit_dbg("wait %ld tick for SCL line to go high\n", 
-			rt_tick_get() - start);
-	}
-#endif
-
-done:
-	i2c_delay(ops);
-
-	return RT_EOK;
-}
-
-
-static void i2c_start(struct rt_i2c_bit_ops *ops)
-{
-#ifdef RT_I2C_BIT_DEBUG
-	if (ops->get_scl && !GET_SCL(ops))
-	{
-		bit_dbg("I2C bus error, SCL line low\n");
-	}
-	if (ops->get_sda && !GET_SDA(ops))
-	{
-		bit_dbg("I2C bus error, SDA line low\n");
-	}
-#endif
-	SDA_L(ops);
-	i2c_delay(ops);
-	SCL_L(ops);
-}
-
-static void i2c_restart(struct rt_i2c_bit_ops *ops)
-{
-	SDA_H(ops);
-	SCL_H(ops);
-	i2c_delay(ops);
-	SDA_L(ops);
-	i2c_delay(ops);
-	SCL_L(ops);
-}
-
-
-static void i2c_stop(struct rt_i2c_bit_ops *ops)
-{
-	SDA_L(ops);
-	i2c_delay(ops);
-	SCL_H(ops);
-	i2c_delay(ops);
-	SDA_H(ops);
-	i2c_delay2(ops);
-}
-
-rt_inline rt_bool_t i2c_waitack(struct rt_i2c_bit_ops *ops)
-{
-	rt_bool_t ack;
-
-	SDA_H(ops);
-	i2c_delay(ops);
-	
-	if (SCL_H(ops) < 0) 
-	{
-		bit_dbg("wait ack timeout\n");
-		return -RT_ETIMEOUT;
-	}
-
-	ack = !GET_SDA(ops);    /* ACK : SDA pin is pulled low */
-	bit_dbg("%s\n", ack ? "ACK" : "NACK");
-
-	SCL_L(ops);
-
-	return ack;
-}
-
-
-static rt_int32_t i2c_writeb(struct rt_i2c_bus_device *bus, rt_uint8_t data)
-{
-	rt_int32_t i;
-	rt_uint8_t bit;
-
-	struct rt_i2c_bit_ops *ops = bus->priv;
-
-	for (i = 7; i >= 0; i--) 
-	{
-		SCL_L(ops);
-		bit = (data >> i) & 1;
-		SET_SDA(ops, bit);
-		i2c_delay(ops);
-		if (SCL_H(ops) < 0) 
-		{
-			bit_dbg("i2c_writeb: 0x%02x, "
-				"wait scl pin high timeout at bit %d\n", 
-				data, i);
-			return -RT_ETIMEOUT;
-		}
-		
-	}
-	SCL_L(ops);
-	i2c_delay(ops);
-
-	return i2c_waitack(ops);
-}
-
-
-static rt_int32_t i2c_readb(struct rt_i2c_bus_device *bus)
-{
-	rt_uint8_t i;
-	rt_uint8_t data = 0;
-	struct rt_i2c_bit_ops *ops = bus->priv;
-
-	SDA_H(ops);
-	i2c_delay(ops);
-	for (i = 0; i < 8; i++) 
-	{
-		data <<= 1;
-
-		if (SCL_H(ops) < 0) 
-		{
-			bit_dbg("i2c_readb: wait scl pin high "
-				"timeout at bit %d\n", 7 - i);
-			return -RT_ETIMEOUT;
-		}
-		
-		if (GET_SDA(ops))
-			data |= 1;
-		SCL_L(ops);
-		i2c_delay2(ops);
-	}
-
-	return data;
-}
-
-
-static rt_size_t i2c_send_bytes(struct rt_i2c_bus_device *bus, struct rt_i2c_msg *msg)
-{
-	rt_int32_t ret;
-	rt_size_t bytes = 0;
-	const rt_uint8_t *ptr = msg->buf;
-	rt_int32_t count = msg->len;
-	rt_uint16_t ignore_nack = msg->flags & RT_I2C_IGNORE_NACK;
-
-	while (count > 0) 
-	{
-		ret = i2c_writeb(bus, *ptr);
-
-		if ((ret > 0) || (ignore_nack && (ret == 0))) 
-		{
-			count--;
-			ptr++;
-			bytes++;
-		} 
-		else if (ret == 0) 
-		{
-			rt_kprintf("send bytes: NACK.\n");
-			return -RT_ERROR;
-		} 
-		else 
-		{
-			rt_kprintf("send bytes: error %d\n", ret);
-			return ret;
-		}
-	}
-	return bytes;
-}
-
-static rt_err_t i2c_send_ack_or_nack(struct rt_i2c_bus_device *bus, int ack)
-{
-	struct rt_i2c_bit_ops *ops = bus->priv;
-
-	if (ack)
-		SET_SDA(ops, 0);
-	i2c_delay(ops);
-	if (SCL_H(ops) < 0) 
-	{
-		rt_kprintf("ACK or NACK timeout\n");
-		return -RT_ETIMEOUT;
-	}
-	SCL_L(ops);
-	return RT_EOK;
-}
-
-static rt_size_t i2c_recv_bytes(struct rt_i2c_bus_device *bus, struct rt_i2c_msg *msg)
-{
-	rt_int32_t val;
-	rt_int32_t bytes = 0;	/* actual bytes */
-	rt_uint8_t *ptr = msg->buf;
-	rt_int32_t count = msg->len;
-	const rt_uint32_t flags = msg->flags;
-
-	while (count > 0) 
-	{
-		val = i2c_readb(bus);
-		if (val >= 0) 
-		{
-			*ptr = val;
-			bytes++;
-		} 
-		else 
-		{
-			break;
-		}
-
-		ptr++;
-		count--;
-
-		bit_dbg("recieve bytes: 0x%02x, %s\n", 
-			val, (flags & RT_I2C_NO_READ_ACK) ? 
-			"(No ACK/NACK)" : (count ? "ACK" : "NACK"));
-
-		if (!(flags & RT_I2C_NO_READ_ACK)) 
-		{
-			val = i2c_send_ack_or_nack(bus, count);
-			if (val < 0)
-				return val;
-		}
-	}
-	return bytes;
-}
-
-static rt_int32_t i2c_send_address(struct rt_i2c_bus_device *bus,
-		       rt_uint8_t addr, rt_int32_t retries)
-{
-	struct rt_i2c_bit_ops *ops = bus->priv;
-	rt_int32_t i;
-	rt_err_t ret = 0;
-
-	for (i = 0; i <= retries; i++)
-	{
-		ret = i2c_writeb(bus, addr);
-		if (ret == 1 || i == retries)
-			break;
-		bit_dbg("send stop condition\n");
-		i2c_stop(ops);
-		i2c_delay2(ops);
-		bit_dbg("send start condition\n");
-		i2c_start(ops);
-	}
-
-	return ret;
-}
-
-static rt_err_t i2c_bit_send_address(struct rt_i2c_bus_device *bus, struct rt_i2c_msg *msg)
-{
-	rt_uint16_t flags = msg->flags;
-	rt_uint16_t ignore_nack = msg->flags & RT_I2C_IGNORE_NACK;
-	struct rt_i2c_bit_ops *ops = bus->priv;
-
-	rt_uint8_t addr1, addr2;
-	rt_int32_t retries;
-	rt_err_t  ret;
-
-	retries = ignore_nack ? 0 : bus->retries;
-
-	if (flags & RT_I2C_ADDR_10BIT)
-	{
-		addr1 = 0xf0 | ((msg->addr >> 7) & 0x06);
-		addr2 = msg->addr & 0xff;
-
-		bit_dbg("addr1: %d, addr2: %d\n", addr1, addr2);
-
-		ret = i2c_send_address(bus, addr1, retries);
-		if ((ret != 1) && !ignore_nack)
-		{
-			rt_kprintf("NACK: sending first addr\n");
-			return -RT_EIO;
-		}
-
-		ret = i2c_writeb(bus, addr2);
-		if ((ret != 1) && !ignore_nack)
-		{
-			rt_kprintf("NACK: sending second addr\n");
-			return -RT_EIO;
-		}
-		if (flags & RT_I2C_RD)
-		{
-			bit_dbg("send repeated start condition\n");
-			i2c_restart(ops);
-			addr1 |= 0x01;
-			ret = i2c_send_address(bus, addr1, retries);
-			if ((ret != 1) && !ignore_nack)
-			{
-				rt_kprintf("NACK: sending repeated addr\n");
-				return -RT_EIO;
-			}
-		}
-	}
-	else
-	{ /* 7-bit addr */
-		addr1 = msg->addr << 1;
-		if (flags & RT_I2C_RD)
-			addr1 |= 1;
-		ret = i2c_send_address(bus, addr1, retries);
-		if ((ret != 1) && !ignore_nack)
-			return -RT_EIO;
-	}
-
-	return RT_EOK;
-}
-
-
-static rt_size_t i2c_bit_xfer(struct rt_i2c_bus_device *bus,
-		    struct rt_i2c_msg msgs[], rt_uint32_t num)
-{
-	struct rt_i2c_msg *msg;
-	struct rt_i2c_bit_ops *ops = bus->priv;
-	rt_int32_t i, ret;
-	rt_uint16_t ignore_nack;
-
-	bit_dbg("send start condition\n");
-	i2c_start(ops);
-	for (i = 0; i < num; i++)
-	{
-		msg = &msgs[i];
-		ignore_nack = msg->flags & RT_I2C_IGNORE_NACK;
-		if (!(msg->flags & RT_I2C_NO_START))
-		{
-			if (i)
-			{
-				i2c_restart(ops);
-			}
-			ret = i2c_bit_send_address(bus, msg);
-			if ((ret != RT_EOK) && !ignore_nack)
-			{
-				bit_dbg("receive NACK from device addr 0x%02x msg %d\n",
-					msgs[i].addr, i);
-				goto out;
-			}
-		}
-		if (msg->flags & RT_I2C_RD)
-		{
-			ret = i2c_recv_bytes(bus, msg);
-			if (ret >= 1)
-				bit_dbg("read %d byte%s\n",
-					ret, ret == 1 ? "" : "s");
-			if (ret < msg->len)
-			{
-				if (ret >= 0)
-					ret = -RT_EIO;
-				goto out;
-			}
-		}
-		else
-		{
-			ret = i2c_send_bytes(bus, msg);
-			if (ret >= 1)
-				bit_dbg("write %d byte%s\n",
-					ret, ret == 1 ? "" : "s");
-			if (ret < msg->len)
-			{
-				if (ret >= 0)
-					ret = -RT_ERROR;
-				goto out;
-			}
-		}
-	}
-	ret = i;
-
-out:
-	bit_dbg("send stop condition\n");
-	i2c_stop(ops);
-
-	return ret;
-}
-
-
-static const struct rt_i2c_bus_device_ops i2c_bit_bus_ops = {
-	i2c_bit_xfer,
-	RT_NULL,
-	RT_NULL
-};
-
-
-rt_err_t rt_i2c_bit_add_bus(struct rt_i2c_bus_device *bus, const char *bus_name)
-{
-	rt_err_t err;
-
-	struct rt_i2c_bit_ops *bit_ops = bus->priv;
-	RT_ASSERT(bit_ops != RT_NULL);
-
-	bus->ops = &i2c_bit_bus_ops;
-
-	return rt_i2c_bus_device_register(bus, bus_name);
-}
+/*

+ * File      : i2c-bit-ops.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>

+

+#ifdef RT_I2C_BIT_DEBUG

+#define bit_dbg(fmt, ...)	rt_kprintf(fmt, ##__VA_ARGS__)

+#else

+#define bit_dbg(fmt, ...)

+#endif

+

+

+#define SET_SDA(ops, val)	ops->set_sda(ops->data, val)

+#define SET_SCL(ops, val)	ops->set_scl(ops->data, val)

+#define GET_SDA(ops)		ops->get_sda(ops->data)

+#define GET_SCL(ops)		ops->get_scl(ops->data)

+

+rt_inline void i2c_delay(struct rt_i2c_bit_ops *ops)

+{

+    ops->udelay((ops->delay_us + 1) >> 1);

+}

+

+rt_inline void i2c_delay2(struct rt_i2c_bit_ops *ops)

+{

+    ops->udelay(ops->delay_us);

+}

+

+#define SDA_L(ops)	SET_SDA(ops, 0)

+#define SDA_H(ops)	SET_SDA(ops, 1)

+#define SCL_L(ops)	SET_SCL(ops, 0)

+

+/*

+ * release scl line, and wait scl line to high.

+ */

+static rt_err_t SCL_H(struct rt_i2c_bit_ops *ops)

+{

+    rt_tick_t start;

+

+    SET_SCL(ops, 1);

+

+    if (!ops->get_scl)

+        goto done;

+

+    start = rt_tick_get();

+    while (!GET_SCL(ops))

+    {

+        if ((rt_tick_get() - start) > ops->timeout)

+            return -RT_ETIMEOUT;

+        rt_thread_delay((ops->timeout + 1) >> 1);

+    }

+#ifdef RT_I2C_BIT_DEBUG

+    if (rt_tick_get() != start)

+    {

+        bit_dbg("wait %ld tick for SCL line to go high\n",

+                rt_tick_get() - start);

+    }

+#endif

+

+done:

+    i2c_delay(ops);

+

+    return RT_EOK;

+}

+

+

+static void i2c_start(struct rt_i2c_bit_ops *ops)

+{

+#ifdef RT_I2C_BIT_DEBUG

+    if (ops->get_scl && !GET_SCL(ops))

+    {

+        bit_dbg("I2C bus error, SCL line low\n");

+    }

+    if (ops->get_sda && !GET_SDA(ops))

+    {

+        bit_dbg("I2C bus error, SDA line low\n");

+    }

+#endif

+    SDA_L(ops);

+    i2c_delay(ops);

+    SCL_L(ops);

+}

+

+static void i2c_restart(struct rt_i2c_bit_ops *ops)

+{

+    SDA_H(ops);

+    SCL_H(ops);

+    i2c_delay(ops);

+    SDA_L(ops);

+    i2c_delay(ops);

+    SCL_L(ops);

+}

+

+

+static void i2c_stop(struct rt_i2c_bit_ops *ops)

+{

+    SDA_L(ops);

+    i2c_delay(ops);

+    SCL_H(ops);

+    i2c_delay(ops);

+    SDA_H(ops);

+    i2c_delay2(ops);

+}

+

+rt_inline rt_bool_t i2c_waitack(struct rt_i2c_bit_ops *ops)

+{

+    rt_bool_t ack;

+

+    SDA_H(ops);

+    i2c_delay(ops);

+

+    if (SCL_H(ops) < 0)

+    {

+        bit_dbg("wait ack timeout\n");

+        return -RT_ETIMEOUT;

+    }

+

+    ack = !GET_SDA(ops);    /* ACK : SDA pin is pulled low */

+    bit_dbg("%s\n", ack ? "ACK" : "NACK");

+

+    SCL_L(ops);

+

+    return ack;

+}

+

+

+static rt_int32_t i2c_writeb(struct rt_i2c_bus_device *bus, rt_uint8_t data)

+{

+    rt_int32_t i;

+    rt_uint8_t bit;

+

+    struct rt_i2c_bit_ops *ops = bus->priv;

+

+    for (i = 7; i >= 0; i--)

+    {

+        SCL_L(ops);

+        bit = (data >> i) & 1;

+        SET_SDA(ops, bit);

+        i2c_delay(ops);

+        if (SCL_H(ops) < 0)

+        {

+            bit_dbg("i2c_writeb: 0x%02x, "

+                    "wait scl pin high timeout at bit %d\n",

+                    data, i);

+            return -RT_ETIMEOUT;

+        }

+

+    }

+    SCL_L(ops);

+    i2c_delay(ops);

+

+    return i2c_waitack(ops);

+}

+

+

+static rt_int32_t i2c_readb(struct rt_i2c_bus_device *bus)

+{

+    rt_uint8_t i;

+    rt_uint8_t data = 0;

+    struct rt_i2c_bit_ops *ops = bus->priv;

+

+    SDA_H(ops);

+    i2c_delay(ops);

+    for (i = 0; i < 8; i++)

+    {

+        data <<= 1;

+

+        if (SCL_H(ops) < 0)

+        {

+            bit_dbg("i2c_readb: wait scl pin high "

+                    "timeout at bit %d\n", 7 - i);

+            return -RT_ETIMEOUT;

+        }

+

+        if (GET_SDA(ops))

+            data |= 1;

+        SCL_L(ops);

+        i2c_delay2(ops);

+    }

+

+    return data;

+}

+

+

+static rt_size_t i2c_send_bytes(struct rt_i2c_bus_device *bus, struct rt_i2c_msg *msg)

+{

+    rt_int32_t ret;

+    rt_size_t bytes = 0;

+    const rt_uint8_t *ptr = msg->buf;

+    rt_int32_t count = msg->len;

+    rt_uint16_t ignore_nack = msg->flags & RT_I2C_IGNORE_NACK;

+

+    while (count > 0)

+    {

+        ret = i2c_writeb(bus, *ptr);

+

+        if ((ret > 0) || (ignore_nack && (ret == 0)))

+        {

+            count--;

+            ptr++;

+            bytes++;

+        }

+        else if (ret == 0)

+        {

+            i2c_dbg("send bytes: NACK.\n");

+            return 0;

+        }

+        else

+        {

+            i2c_dbg("send bytes: error %d\n", ret);

+            return ret;

+        }

+    }

+    return bytes;

+}

+

+static rt_err_t i2c_send_ack_or_nack(struct rt_i2c_bus_device *bus, int ack)

+{

+    struct rt_i2c_bit_ops *ops = bus->priv;

+

+    if (ack)

+        SET_SDA(ops, 0);

+    i2c_delay(ops);

+    if (SCL_H(ops) < 0)

+    {

+        bit_dbg("ACK or NACK timeout\n");

+        return -RT_ETIMEOUT;

+    }

+    SCL_L(ops);

+    return RT_EOK;

+}

+

+static rt_size_t i2c_recv_bytes(struct rt_i2c_bus_device *bus, struct rt_i2c_msg *msg)

+{

+    rt_int32_t val;

+    rt_int32_t bytes = 0;	/* actual bytes */

+    rt_uint8_t *ptr = msg->buf;

+    rt_int32_t count = msg->len;

+    const rt_uint32_t flags = msg->flags;

+

+    while (count > 0)

+    {

+        val = i2c_readb(bus);

+        if (val >= 0)

+        {

+            *ptr = val;

+            bytes++;

+        }

+        else

+        {

+            break;

+        }

+

+        ptr++;

+        count--;

+

+        bit_dbg("recieve bytes: 0x%02x, %s\n",

+                val, (flags & RT_I2C_NO_READ_ACK) ?

+                "(No ACK/NACK)" : (count ? "ACK" : "NACK"));

+

+        if (!(flags & RT_I2C_NO_READ_ACK))

+        {

+            val = i2c_send_ack_or_nack(bus, count);

+            if (val < 0)

+                return val;

+        }

+    }

+    return bytes;

+}

+

+static rt_int32_t i2c_send_address(struct rt_i2c_bus_device *bus,

+                                   rt_uint8_t addr, rt_int32_t retries)

+{

+    struct rt_i2c_bit_ops *ops = bus->priv;

+    rt_int32_t i;

+    rt_err_t ret = 0;

+

+    for (i = 0; i <= retries; i++)

+    {

+        ret = i2c_writeb(bus, addr);

+        if (ret == 1 || i == retries)

+            break;

+        bit_dbg("send stop condition\n");

+        i2c_stop(ops);

+        i2c_delay2(ops);

+        bit_dbg("send start condition\n");

+        i2c_start(ops);

+    }

+

+    return ret;

+}

+

+static rt_err_t i2c_bit_send_address(struct rt_i2c_bus_device *bus, struct rt_i2c_msg *msg)

+{

+    rt_uint16_t flags = msg->flags;

+    rt_uint16_t ignore_nack = msg->flags & RT_I2C_IGNORE_NACK;

+    struct rt_i2c_bit_ops *ops = bus->priv;

+

+    rt_uint8_t addr1, addr2;

+    rt_int32_t retries;

+    rt_err_t  ret;

+

+    retries = ignore_nack ? 0 : bus->retries;

+

+    if (flags & RT_I2C_ADDR_10BIT)

+    {

+        addr1 = 0xf0 | ((msg->addr >> 7) & 0x06);

+        addr2 = msg->addr & 0xff;

+

+        bit_dbg("addr1: %d, addr2: %d\n", addr1, addr2);

+

+        ret = i2c_send_address(bus, addr1, retries);

+        if ((ret != 1) && !ignore_nack)

+        {

+            bit_dbg("NACK: sending first addr\n");

+            return -RT_EIO;

+        }

+

+        ret = i2c_writeb(bus, addr2);

+        if ((ret != 1) && !ignore_nack)

+        {

+            bit_dbg("NACK: sending second addr\n");

+            return -RT_EIO;

+        }

+        if (flags & RT_I2C_RD)

+        {

+            bit_dbg("send repeated start condition\n");

+            i2c_restart(ops);

+            addr1 |= 0x01;

+            ret = i2c_send_address(bus, addr1, retries);

+            if ((ret != 1) && !ignore_nack)

+            {

+                bit_dbg("NACK: sending repeated addr\n");

+                return -RT_EIO;

+            }

+        }

+    }

+    else

+    {

+        /* 7-bit addr */

+        addr1 = msg->addr << 1;

+        if (flags & RT_I2C_RD)

+            addr1 |= 1;

+        ret = i2c_send_address(bus, addr1, retries);

+        if ((ret != 1) && !ignore_nack)

+            return -RT_EIO;

+    }

+

+    return RT_EOK;

+}

+

+

+static rt_size_t i2c_bit_xfer(struct rt_i2c_bus_device *bus,

+                              struct rt_i2c_msg msgs[], rt_uint32_t num)

+{

+    struct rt_i2c_msg *msg;

+    struct rt_i2c_bit_ops *ops = bus->priv;

+    rt_int32_t i, ret;

+    rt_uint16_t ignore_nack;

+

+    bit_dbg("send start condition\n");

+    i2c_start(ops);

+    for (i = 0; i < num; i++)

+    {

+        msg = &msgs[i];

+        ignore_nack = msg->flags & RT_I2C_IGNORE_NACK;

+        if (!(msg->flags & RT_I2C_NO_START))

+        {

+            if (i)

+            {

+                i2c_restart(ops);

+            }

+            ret = i2c_bit_send_address(bus, msg);

+            if ((ret != RT_EOK) && !ignore_nack)

+            {

+                bit_dbg("receive NACK from device addr 0x%02x msg %d\n",

+                        msgs[i].addr, i);

+                goto out;

+            }

+        }

+        if (msg->flags & RT_I2C_RD)

+        {

+            ret = i2c_recv_bytes(bus, msg);

+            if (ret >= 1)

+                bit_dbg("read %d byte%s\n",

+                        ret, ret == 1 ? "" : "s");

+            if (ret < msg->len)

+            {

+                if (ret >= 0)

+                    ret = -RT_EIO;

+                goto out;

+            }

+        }

+        else

+        {

+            ret = i2c_send_bytes(bus, msg);

+            if (ret >= 1)

+                bit_dbg("write %d byte%s\n",

+                        ret, ret == 1 ? "" : "s");

+            if (ret < msg->len)

+            {

+                if (ret >= 0)

+                    ret = -RT_ERROR;

+                goto out;

+            }

+        }

+    }

+    ret = i;

+

+out:

+    bit_dbg("send stop condition\n");

+    i2c_stop(ops);

+

+    return ret;

+}

+

+

+static const struct rt_i2c_bus_device_ops i2c_bit_bus_ops =

+{

+    i2c_bit_xfer,

+    RT_NULL,

+    RT_NULL

+};

+

+

+rt_err_t rt_i2c_bit_add_bus(struct rt_i2c_bus_device *bus, const char *bus_name)

+{

+    struct rt_i2c_bit_ops *bit_ops = bus->priv;

+    RT_ASSERT(bit_ops != RT_NULL);

+

+    bus->ops = &i2c_bit_bus_ops;

+

+    return rt_i2c_bus_device_register(bus, bus_name);

+}

diff --git a/components/drivers/i2c/i2c_core.c b/components/drivers/i2c/i2c_core.c
index 2bd4f4615d..6fa3fcc887 100644
--- a/components/drivers/i2c/i2c_core.c
+++ b/components/drivers/i2c/i2c_core.c
@@ -1,129 +1,135 @@
-/*
- * 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
-	{
-		rt_kprintf("I2C bus operation not supported\n");
-		return -RT_ERROR;
-	}
-}
-
-
-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)
-{
-
-	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, 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);

+}

+

diff --git a/components/drivers/i2c/i2c_dev.c b/components/drivers/i2c/i2c_dev.c
index 5743903ac0..d1fc55567b 100644
--- a/components/drivers/i2c/i2c_dev.c
+++ b/components/drivers/i2c/i2c_dev.c
@@ -1,105 +1,113 @@
-#include <rtdevice.h>

+#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);

+    struct rt_i2c_bus_device* bus = (struct rt_i2c_bus_device *)dev->user_data;

+    RT_ASSERT(bus != RT_NULL);

 

-	return RT_EOK;

+    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)

+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);

+    rt_uint16_t addr;

+    rt_uint16_t flags;

+    struct rt_i2c_bus_device* bus = (struct rt_i2c_bus_device *)dev->user_data;

 

-	i2c_dbg("I2C bus dev [%s] reading %u bytes.\n", dev->parent.name, count);

+    RT_ASSERT(bus != RT_NULL);

+    RT_ASSERT(buffer != RT_NULL);

 

-	addr = pos & 0xffff;

-	flags = (pos >> 16) & 0xffff;

+    i2c_dbg("I2C bus dev [%s] reading %u bytes.\n", dev->parent.name, count);

 

-	return rt_i2c_master_recv(bus, addr, flags, buffer, 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)

+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_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);

+    RT_ASSERT(bus != RT_NULL);

+    RT_ASSERT(buffer != RT_NULL);

 

-	i2c_dbg("I2C bus dev writing %u bytes.\n", dev->parent.name, count);

+    i2c_dbg("I2C bus dev writing %u bytes.\n", dev->parent.name, count);

 

-	addr = pos & 0xffff;

-	flags = (pos >> 16) & 0xffff;

+    addr = pos & 0xffff;

+    flags = (pos >> 16) & 0xffff;

 

-	return rt_i2c_master_send(bus, addr, flags, buffer, count);

+    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)

+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_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);

+    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;

-	}

+    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;

+    return RT_EOK;

 }

 

 

-rt_err_t rt_i2c_bus_device_device_init(struct rt_i2c_bus_device* bus, const char* name)

+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;

+    struct rt_device *device;

+    RT_ASSERT(bus != RT_NULL);

 

-	/* 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;

+    device = &bus->parent;

 

-	/* register to device manager */

-	rt_device_register(device, name, RT_DEVICE_FLAG_RDWR);

+    device->user_data = bus;

 

-	return RT_EOK;

-}

+    /* 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;

+}

diff --git a/components/drivers/include/drivers/i2c-bit-ops.h b/components/drivers/include/drivers/i2c-bit-ops.h
index 8b9253d9ff..bf9bd810a5 100644
--- a/components/drivers/include/drivers/i2c-bit-ops.h
+++ b/components/drivers/include/drivers/i2c-bit-ops.h
@@ -1,41 +1,43 @@
-/*
- * 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
\ No newline at end of file
+/*

+ * 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

diff --git a/components/drivers/include/drivers/i2c.h b/components/drivers/include/drivers/i2c.h
index 69b43e95b4..e966e24558 100644
--- a/components/drivers/include/drivers/i2c.h
+++ b/components/drivers/include/drivers/i2c.h
@@ -1,79 +1,95 @@
-/*
- * 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, 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

diff --git a/components/drivers/include/drivers/i2c_dev.h b/components/drivers/include/drivers/i2c_dev.h
index b173e99333..8a2c2bef21 100644
--- a/components/drivers/include/drivers/i2c_dev.h
+++ b/components/drivers/include/drivers/i2c_dev.h
@@ -1,27 +1,29 @@
-#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
\ No newline at end of file
+#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

diff --git a/components/drivers/include/rtdevice.h b/components/drivers/include/rtdevice.h
index 77dbddd9ae..e1fcc2f9a2 100644
--- a/components/drivers/include/rtdevice.h
+++ b/components/drivers/include/rtdevice.h
@@ -1,79 +1,88 @@
-#ifndef __RT_DEVICE_H__
-#define __RT_DEVICE_H__
-
-#include <rtthread.h>
-
-#define RT_DEVICE(device)	((rt_device_t)device)
-
-/* completion flag */
-struct rt_completion
-{
-	rt_uint32_t flag;
-
-	/* suspended list */
-	rt_list_t suspended_list;
-};
-
-/* ring buffer */
-struct rt_ringbuffer
-{
-	rt_uint16_t read_index, write_index;
-	rt_uint8_t *buffer_ptr;
-	rt_uint16_t buffer_size;
-};
-
-/**
- * Completion
- */
-void rt_completion_init(struct rt_completion* completion);
-rt_err_t rt_completion_wait(struct rt_completion* completion, rt_int32_t timeout);
-void rt_completion_done(struct rt_completion* completion);
-
-/**
- * DataLink for DeviceDriver
- */
-
-/**
- * RingBuffer for DeviceDriver
- */
-void rt_ringbuffer_init(struct rt_ringbuffer* rb, rt_uint8_t *pool, rt_uint16_t size);
-rt_size_t rt_ringbuffer_put(struct rt_ringbuffer* rb, const rt_uint8_t *ptr, rt_uint16_t length);
-rt_size_t rt_ringbuffer_putchar(struct rt_ringbuffer* rb, const rt_uint8_t ch);
-rt_size_t rt_ringbuffer_get(struct rt_ringbuffer* rb, rt_uint8_t *ptr, rt_uint16_t length);
-rt_size_t rt_ringbuffer_available_size(struct rt_ringbuffer* rb);
-rt_size_t rt_ringbuffer_emptry_size(struct rt_ringbuffer* rb);
-
-#ifdef RT_USING_SPI
-#include "drivers/spi.h"
-#endif
-
-#ifdef RT_USING_MTD_NOR
-#include "drivers/mtd_nor.h"
-#endif
-
-#ifdef RT_USING_MTD_NAND
-#include "drivers/mtd_nand.h"
-#endif
-
-#ifdef RT_USING_USB_DEVICE
-#include "drivers/usb_device.h"
-#endif
-
-#ifdef RT_USING_USB_HOST
-#include "drivers/usb_host.h"
-#endif
-
-#ifdef RT_USING_SERIAL
-#include "drivers/serial.h"
-#endif
-
-#ifdef RT_USING_I2C
-#include "drivers/i2c.h"
-#include "drivers/i2c_dev.h"
-#endif
-
-#ifdef RT_USING_I2C_BITOPS
-#include "drivers/i2c-bit-ops.h"
-#endif
-
-#endif
+#ifndef __RT_DEVICE_H__

+#define __RT_DEVICE_H__

+

+#include <rtthread.h>

+

+#define RT_DEVICE(device)	((rt_device_t)device)

+

+/* completion flag */

+struct rt_completion

+{

+    rt_uint32_t flag;

+

+    /* suspended list */

+    rt_list_t suspended_list;

+};

+

+/* ring buffer */

+struct rt_ringbuffer

+{

+    rt_uint16_t read_index, write_index;

+    rt_uint8_t *buffer_ptr;

+    rt_uint16_t buffer_size;

+};

+

+/**

+ * Completion

+ */

+void rt_completion_init(struct rt_completion* completion);

+rt_err_t rt_completion_wait(struct rt_completion* completion,

+                            rt_int32_t timeout);

+void rt_completion_done(struct rt_completion* completion);

+

+/**

+ * DataLink for DeviceDriver

+ */

+

+/**

+ * RingBuffer for DeviceDriver

+ */

+void rt_ringbuffer_init(struct rt_ringbuffer* rb,

+                        rt_uint8_t *pool,

+                        rt_uint16_t size);

+rt_size_t rt_ringbuffer_put(struct rt_ringbuffer* rb,

+                            const rt_uint8_t *ptr,

+                            rt_uint16_t length);

+rt_size_t rt_ringbuffer_putchar(struct rt_ringbuffer* rb,

+                                const rt_uint8_t ch);

+rt_size_t rt_ringbuffer_get(struct rt_ringbuffer* rb,

+                            rt_uint8_t *ptr,

+                            rt_uint16_t length);

+rt_size_t rt_ringbuffer_available_size(struct rt_ringbuffer* rb);

+rt_size_t rt_ringbuffer_emptry_size(struct rt_ringbuffer* rb);

+

+#ifdef RT_USING_SPI

+#include "drivers/spi.h"

+#endif /* RT_USING_SPI */

+

+#ifdef RT_USING_MTD_NOR

+#include "drivers/mtd_nor.h"

+#endif /* RT_USING_MTD_NOR */

+

+#ifdef RT_USING_MTD_NAND

+#include "drivers/mtd_nand.h"

+#endif /* RT_USING_MTD_NAND */

+

+#ifdef RT_USING_USB_DEVICE

+#include "drivers/usb_device.h"

+#endif /* RT_USING_USB_DEVICE */

+

+#ifdef RT_USING_USB_HOST

+#include "drivers/usb_host.h"

+#endif /* RT_USING_USB_HOST */

+

+#ifdef RT_USING_SERIAL

+#include "drivers/serial.h"

+#endif /* RT_USING_SERIAL */

+

+#ifdef RT_USING_I2C

+#include "drivers/i2c.h"

+#include "drivers/i2c_dev.h"

+

+#ifdef RT_USING_I2C_BITOPS

+#include "drivers/i2c-bit-ops.h"

+#endif /* RT_USING_I2C_BITOPS */

+

+#endif /* RT_USING_I2C */

+

+#endif /* __RT_DEVICE_H__ */