fixed a eclipse compiling warning.

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

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

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

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

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

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

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
+#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/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__ */