ADD I2C driver framework and I2C gpio driver

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

components/drivers/i2c/SConscript

+Import('RTT_ROOT')
+from building import *
+
+cwd = GetCurrentDir()
+src = Split("""
+i2c_core.c
+i2c_dev.c
+""")
+
+if GetDepend('RT_USING_I2C_BITOPS'):
+    src = src + ['i2c-bit-ops.c']
+
+# The set of source files associated with this SConscript file.
+path = [cwd]
+
+group = DefineGroup('DeviceDrivers', src, depend = ['RT_USING_I2C'], CPPPATH = path)
+
+Return('group')

components/drivers/i2c/i2c-bit-ops.c

+/*
+ * 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 <i2c.h>
+#include <i2c-bit-ops.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 *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 *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 *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 *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 *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 *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 *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 *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_ops i2c_bit_bus_ops = {
+	i2c_bit_xfer,
+	RT_NULL,
+	RT_NULL
+};
+
+
+rt_err_t rt_i2c_bit_add_bus(struct rt_i2c_bus *bus)
+{
+	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_register(bus);
+}

components/drivers/i2c/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 *bus);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
\ No newline at end of file

components/drivers/i2c/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
+
+#ifndef RT_I2C_NAME_SIZE
+#define RT_I2C_NAME_SIZE 32
+#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_hardware_info {
+	char name[RT_I2C_NAME_SIZE];
+	rt_uint16_t flags;
+	rt_uint16_t addr;
+	rt_uint32_t bus_id;
+	rt_list_t  list;
+};
+
+#define RT_I2C_HARDWARE_INFO(name, flags, addr, bus_id) \
+	name,flags,addr,bus_id,{RT_NULL,RT_NULL}
+
+struct rt_i2c_bus;
+
+struct rt_i2c_bus_ops {
+	rt_size_t (*master_xfer) (struct rt_i2c_bus *bus, struct rt_i2c_msg *msgs, rt_uint32_t num);
+	rt_size_t (*slave_xfer) (struct rt_i2c_bus *bus, struct rt_i2c_msg *msgs, rt_uint32_t num);
+	rt_err_t (*i2c_bus_control) (struct rt_i2c_bus *bus, rt_uint32_t, rt_uint32_t);
+};
+
+/*for i2c bus driver*/
+struct rt_i2c_bus {
+	struct rt_device *parent;
+	char name[RT_I2C_NAME_SIZE];
+	rt_uint32_t id;
+	const struct rt_i2c_bus_ops *ops;
+	struct rt_mutex lock;
+	rt_list_t devices;
+	rt_list_t list;
+	rt_uint32_t  timeout;
+	rt_uint32_t  retries;
+	void *priv;
+};
+
+struct rt_i2c_device;
+struct rt_i2c_driver {
+	char name[RT_I2C_NAME_SIZE];
+	rt_err_t (*probe)(struct rt_i2c_device *device);
+	rt_err_t (*remove)(struct rt_i2c_device *device);
+	rt_list_t devices;
+};
+
+/*for i2c device driver*/
+struct rt_i2c_device {
+	rt_uint32_t  flags;
+	rt_uint16_t  addr;
+	struct rt_i2c_bus *bus;
+	struct rt_i2c_driver *driver;
+	struct rt_device dev;
+	rt_list_t  drv_list;
+	rt_list_t  bus_list;
+};
+
+#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_register(struct rt_i2c_bus *bus);
+rt_err_t rt_i2c_bus_unregister(struct rt_i2c_bus *bus);
+void rt_i2c_hw_info_register(struct rt_i2c_hardware_info *info, rt_uint32_t size);
+rt_err_t rt_i2c_bus_attach_driver(struct rt_i2c_driver *driver);
+rt_err_t rt_i2c_bus_detach_driver(struct rt_i2c_driver *driver);
+rt_size_t rt_i2c_transfer(struct rt_i2c_bus *bus, 
+			  struct rt_i2c_msg *msgs, rt_uint32_t size);
+rt_size_t rt_i2c_master_send(struct rt_i2c_device *device, 
+			     const rt_uint8_t *buf, rt_uint32_t size);
+rt_size_t rt_i2c_master_recv(struct rt_i2c_device *device, 
+			     rt_uint8_t *buf ,rt_uint32_t size);
+rt_err_t rt_i2c_core_init();
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

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 <i2c.h>
+#include <i2c_dev.h>
+
+static struct rt_mutex i2c_core_lock;
+static struct rt_mutex i2c_hardware_lock;
+static rt_list_t i2c_hw_info_list = RT_LIST_OBJECT_INIT(i2c_hw_info_list);
+static rt_list_t i2c_bus_list = RT_LIST_OBJECT_INIT(i2c_bus_list);
+
+static struct rt_i2c_bus *find_i2c_bus(rt_uint32_t id)
+{
+	rt_list_t *list;
+	struct rt_i2c_bus *bus = RT_NULL;
+
+	for (list = (&i2c_bus_list)->next; list != &i2c_bus_list; list = list->next)
+	{
+		bus = (struct rt_i2c_bus *)rt_list_entry(list, struct rt_i2c_bus, list);
+		if (bus->id == id)
+		{
+			return bus;
+		}
+	}
+
+	return RT_NULL;
+}
+
+
+rt_err_t rt_i2c_bus_register(struct rt_i2c_bus *bus)
+{
+	rt_err_t ret = RT_EOK;
+	struct rt_i2c_bus *tbus;
+
+	rt_mutex_init (&bus->lock, "i2c_bus_lock", RT_IPC_FLAG_FIFO);
+
+	rt_mutex_take(&i2c_core_lock, RT_WAITING_FOREVER);
+
+	tbus = find_i2c_bus(bus->id);
+	if (tbus != RT_NULL)
+	{
+		rt_kprintf("I2C bus ID [%d] already registered\n", bus->id);
+		ret = -RT_ERROR;
+		goto out;
+	}
+
+	if (bus->timeout == 0)
+		bus->timeout = RT_TICK_PER_SECOND;
+	
+	rt_list_init(&bus->devices);
+	
+	ret = rt_i2c_bus_device_init(bus, bus->name);
+	if (ret != RT_EOK)
+	{
+		rt_mutex_release(&i2c_core_lock);
+		rt_kprintf("I2C bus [%s] register failed\n", bus->name);
+		goto out;
+	}
+
+	rt_list_insert_after(&i2c_bus_list, &bus->list);
+
+	rt_mutex_release(&i2c_core_lock);
+
+	rt_kprintf("I2C bus [%s] registered\n", bus->name);
+out:
+	return ret;
+}
+
+
+rt_err_t rt_i2c_bus_unregister(struct rt_i2c_bus *bus)
+{
+	rt_err_t ret = RT_EOK;
+	struct rt_i2c_bus *bus_l;
+	rt_list_t *list;
+	struct rt_i2c_device *device;
+
+	rt_mutex_take(&i2c_core_lock, RT_WAITING_FOREVER);
+	
+	rt_i2c_bus_device_exit(bus);
+	
+	for (list = (&bus->devices)->next; list != &bus->devices; list = list->next)
+	{
+		device = (struct rt_i2c_device *)rt_list_entry(list, struct rt_i2c_device, bus_list);
+		if (device)
+		{
+			ret = device->driver->remove(device);
+			if (ret != RT_EOK)
+			{
+				i2c_dbg("I2C driver [%s] unregister failed\n", device->driver->name);
+				goto out;
+			}
+			rt_list_remove(&device->drv_list);
+			rt_list_remove(&device->bus_list);
+		}
+	}
+	
+	rt_list_init(&bus->devices);
+	rt_list_remove(&bus->list);
+
+	rt_mutex_detach (&bus->lock);
+
+	rt_kprintf("I2C bus [%s] unregister\n", bus->name);
+out:
+	rt_mutex_release(&i2c_core_lock);
+	return ret;
+}
+
+
+rt_inline struct rt_i2c_hardware_info *
+i2c_check_hw_info(struct rt_i2c_hardware_info *hwinfo)
+{
+	rt_list_t *list;
+	struct rt_i2c_hardware_info *info;
+
+	for (list = (&i2c_hw_info_list)->next; list != &i2c_hw_info_list; list = list->next)
+	{
+		info = (struct rt_i2c_hardware_info *)rt_list_entry(list, 
+				struct rt_i2c_hardware_info, list);
+		if ((info->bus_id == hwinfo->bus_id) && (info->addr == hwinfo->addr))
+		{
+			return info;
+		}
+	}
+
+	return RT_NULL;
+}
+
+void rt_i2c_hw_info_register(struct rt_i2c_hardware_info *info, rt_uint32_t size)
+{
+	rt_mutex_take(&i2c_hardware_lock, RT_WAITING_FOREVER);
+	for( ; size > 0; size--, info++)
+	{
+		if (i2c_check_hw_info(info) == RT_NULL)
+		{
+			rt_list_insert_after(&i2c_hw_info_list, &info->list);
+		}
+		else
+		{
+			rt_kprintf("I2C hw info [%s:%d:%d] already registered\n", 
+				   info->name, info->bus_id, info->addr);
+		}
+	}
+	rt_mutex_release(&i2c_hardware_lock);
+}
+
+rt_err_t rt_i2c_check_addr(struct rt_i2c_bus *bus, rt_uint16_t addr)
+{
+	rt_list_t *list;
+	struct rt_i2c_device *device;
+	
+	for (list = (&bus->devices)->next; list != &bus->devices; list = list->next)
+	{
+		device = (struct rt_i2c_device *)rt_list_entry(list, struct rt_i2c_device, bus_list);
+		if (device->addr == addr)
+		{
+			rt_kprintf("ERR: device at addr[0x%02x] "
+				   "already registered\n", addr);
+			return -RT_ERROR;
+		}
+	}
+	
+	return RT_EOK;
+}
+
+static rt_err_t i2c_driver_probe(struct rt_i2c_bus *bus, 
+	struct rt_i2c_driver *driver, struct rt_i2c_hardware_info *info)
+{
+	rt_err_t ret = RT_EOK;
+	struct rt_i2c_device *device;
+
+	device = rt_malloc(sizeof(struct rt_i2c_device));
+	if (device == RT_NULL)
+	{
+		i2c_dbg("I2C malloc memory failed\n");
+		return -RT_ENOMEM;
+	}
+	rt_memset(device, 0, sizeof(struct rt_i2c_device));
+
+	device->flags = info->flags;
+	device->addr = info->addr;
+	device->bus = bus;
+	device->driver = driver;
+	
+	rt_list_insert_after(&bus->devices, &device->bus_list);
+	rt_list_insert_after(&driver->devices, &device->drv_list);
+	ret = driver->probe(device);
+
+	return ret;
+}
+
+static rt_err_t i2c_bus_match_hw(struct rt_i2c_driver *driver)
+{
+	rt_err_t ret = RT_EOK;
+	rt_list_t *list;
+	struct rt_i2c_hardware_info *info;
+	struct rt_i2c_bus *bus = RT_NULL;
+
+	for (list = (&i2c_hw_info_list)->next; list != &i2c_hw_info_list; list = list->next)
+	{
+		info = (struct rt_i2c_hardware_info *)rt_list_entry(list, 
+				struct rt_i2c_hardware_info, list);
+		if (rt_strncmp(info->name, driver->name, RT_I2C_NAME_SIZE) == 0)
+		{
+			bus = find_i2c_bus(info->bus_id);
+			if (bus)
+			{
+				if (rt_i2c_check_addr(bus, info->addr) != RT_EOK)
+				{
+					continue;
+				}
+				if (i2c_driver_probe(bus, driver, info) != RT_EOK)
+				{
+					ret = -RT_ERROR;
+				}
+			}
+		}
+	}
+
+	return ret;
+}
+
+rt_err_t rt_i2c_bus_attach_driver(struct rt_i2c_driver *driver)
+{
+	rt_err_t ret = RT_EOK;
+
+	rt_mutex_take(&i2c_core_lock, RT_WAITING_FOREVER);
+	ret = i2c_bus_match_hw(driver);
+	rt_mutex_release(&i2c_core_lock);
+
+	if (ret != RT_EOK)
+	{
+		goto out;
+	}
+	
+	rt_kprintf("I2C driver [%s] registered\n", driver->name);
+	
+	return RT_EOK;
+
+out:
+	rt_kprintf("I2C driver [%s] register failed\n", driver->name);
+	return ret;
+}
+
+
+rt_err_t rt_i2c_bus_detach_driver(struct rt_i2c_driver *driver)
+{
+	rt_err_t ret = RT_EOK;
+	rt_list_t *list;
+	struct rt_i2c_device *device;
+
+	rt_mutex_take(&i2c_core_lock, RT_WAITING_FOREVER);
+	for (list = (&driver->devices)->next; list != &driver->devices; list = list->next)
+	{
+		device = (struct rt_i2c_device *)rt_list_entry(list, struct rt_i2c_device, drv_list);
+		if (device)
+		{
+			ret = driver->remove(device);
+			if (ret != RT_EOK)
+			{
+				rt_mutex_release(&i2c_core_lock);
+				goto out;
+			}
+			rt_list_remove(&device->drv_list);
+			rt_list_remove(&device->bus_list);
+		}
+	}
+	
+	rt_mutex_release(&i2c_core_lock);
+	
+	rt_kprintf("I2C driver [%s] unregister\n", driver->name);
+	
+out:	
+	return ret;
+}
+
+
+rt_size_t rt_i2c_transfer(struct rt_i2c_bus *bus, 
+			  struct rt_i2c_msg *msgs, rt_uint32_t size)
+{
+	rt_size_t ret;
+
+	if (bus->ops->master_xfer)
+	{
+#ifdef RT_I2C_DEBUG
+		for (ret = 0; ret < size; 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, size);
+		rt_mutex_release(&bus->lock);
+
+		return ret;
+	}
+	else
+	{
+		rt_kprintf("I2C bus transfers not supported\n");
+		return -RT_ERROR;
+	}
+}
+
+
+rt_size_t rt_i2c_master_send(struct rt_i2c_device *device, 
+			     const rt_uint8_t *buf, rt_uint32_t size)
+{
+	rt_size_t ret;
+	struct rt_i2c_msg msg;
+	struct rt_i2c_bus *bus = device->bus;
+
+	msg.addr = device->addr;
+	msg.flags = device->flags & RT_I2C_ADDR_10BIT;
+	msg.len = size;
+	msg.buf = (rt_uint8_t *)buf;
+
+	ret = rt_i2c_transfer(bus, &msg, 1);
+
+	if (ret > 0)
+	{
+		return size;
+	}
+
+	return ret;
+}
+
+
+
+rt_size_t rt_i2c_master_recv(struct rt_i2c_device *device, 
+			     rt_uint8_t *buf, rt_uint32_t size)
+{
+	rt_size_t ret;
+	struct rt_i2c_msg msg;
+	struct rt_i2c_bus *bus = device->bus;
+	RT_ASSERT(bus != RT_NULL);
+
+	msg.addr = device->addr;
+	msg.flags = device->flags & RT_I2C_ADDR_10BIT;
+	msg.flags |= RT_I2C_RD;
+	msg.len = size;
+	msg.buf = buf;
+
+	ret = rt_i2c_transfer(bus, &msg, 1);
+
+	if (ret > 0)
+	{
+		return size;
+	}
+
+	return ret;
+}
+
+
+rt_err_t rt_i2c_core_init()
+{
+	rt_mutex_init (&i2c_core_lock, "i2c_core_lock", RT_IPC_FLAG_FIFO);
+	rt_mutex_init (&i2c_hardware_lock, "i2c_hw_lock", RT_IPC_FLAG_FIFO);
+}
+

components/drivers/i2c/i2c_dev.c

+#include <i2c.h>
+#include <i2c_dev.h>
+
+static rt_err_t i2c_bus_device_init(rt_device_t dev)
+{
+	struct rt_i2c_bus* bus;
+	struct rt_i2c_device *i2c_device = dev->user_data;
+
+	bus = i2c_device->bus;
+	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)
+{
+	struct rt_i2c_bus* bus;
+	struct rt_i2c_device *i2c_device = dev->user_data;
+	
+	bus = i2c_device->bus;
+	RT_ASSERT(bus != RT_NULL);
+	RT_ASSERT(i2c_device != RT_NULL);
+	RT_ASSERT(buffer != RT_NULL);
+
+	i2c_dbg("I2C bus dev [%s] reading %u bytes.\n", bus->name, count);
+
+	return rt_i2c_master_recv(i2c_device, buffer, count);
+}
+
+
+static rt_size_t i2c_bus_device_write (rt_device_t dev, rt_off_t pos, const void *buffer, rt_size_t size)
+{
+	struct rt_i2c_bus* bus;
+	struct rt_i2c_device *i2c_device = dev->user_data;
+	
+	bus = i2c_device->bus;
+	RT_ASSERT(bus != RT_NULL);
+	RT_ASSERT(i2c_device != RT_NULL);
+	RT_ASSERT(buffer != RT_NULL);
+
+	i2c_dbg("I2C bus dev writing %u bytes.\n", bus->name, size);
+
+	return rt_i2c_master_send(i2c_device, buffer, size);
+}
+
+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_bus* bus;
+	struct rt_i2c_priv_data *priv_data;
+	struct rt_i2c_device *i2c_device = dev->user_data;
+
+	bus = i2c_device->bus;
+	RT_ASSERT(bus != RT_NULL);
+	RT_ASSERT(i2c_device != RT_NULL);
+
+	switch (cmd)
+	{
+	case RT_I2C_DEV_CTRL_10BIT: /* set 10-bit addr mode */
+		i2c_device->flags |= RT_I2C_ADDR_10BIT;
+		break;
+	case RT_I2C_DEV_CTRL_ADDR:
+		i2c_device->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_init(struct rt_i2c_bus* bus, const char* name)
+{
+	struct rt_device *device;
+	struct rt_i2c_device *i2c_device;
+	RT_ASSERT(bus != RT_NULL);
+
+	//device = &bus->parent;
+	
+	i2c_device = rt_malloc(sizeof(struct rt_i2c_device));
+	if (i2c_device == RT_NULL)
+	{
+		return -RT_ENOMEM;
+	}
+
+	rt_memset(i2c_device, 0, sizeof(struct rt_i2c_device));
+	
+	device = &i2c_device->dev;
+	i2c_device->bus = bus;
+	bus->parent = device;
+	
+	device->user_data = i2c_device;
+
+	/* 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;
+}
+
+rt_err_t rt_i2c_bus_device_exit(struct rt_i2c_bus* bus)
+{
+	struct rt_device *device;
+	struct rt_i2c_device *i2c_device;
+	RT_ASSERT(bus != RT_NULL);
+
+	device = bus->parent;
+	
+	i2c_device = device->user_data;;
+	
+	/* register to device manager */
+	rt_device_unregister(device);
+	
+	rt_free(i2c_device);
+
+	return RT_EOK;
+}

components/drivers/i2c/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_init(struct rt_i2c_bus* bus, const char* name);
+rt_err_t rt_i2c_bus_device_exit(struct rt_i2c_bus* bus);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
\ No newline at end of file