|
|
@@ -12,362 +12,118 @@
|
|
|
* 2012-04-25 weety first version
|
|
|
*/
|
|
|
|
|
|
-#include <i2c.h>
|
|
|
-#include <i2c_dev.h>
|
|
|
+#include <rtdevice.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_err_t rt_i2c_bus_device_register(struct rt_i2c_bus_device *bus, const char *bus_name)
|
|
|
{
|
|
|
- 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 res = RT_EOK;
|
|
|
|
|
|
-
|
|
|
-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_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);
|
|
|
+
|
|
|
+ res = rt_i2c_bus_device_device_init(bus, bus_name);
|
|
|
|
|
|
- rt_mutex_detach (&bus->lock);
|
|
|
+ i2c_dbg("I2C bus [%s] registered\n", bus_name);
|
|
|
|
|
|
- rt_kprintf("I2C bus [%s] unregister\n", bus->name);
|
|
|
-out:
|
|
|
rt_mutex_release(&i2c_core_lock);
|
|
|
- return ret;
|
|
|
+ return res;
|
|
|
}
|
|
|
|
|
|
|
|
|
-rt_inline struct rt_i2c_hardware_info *
|
|
|
-i2c_check_hw_info(struct rt_i2c_hardware_info *hwinfo)
|
|
|
+struct rt_i2c_bus_device* rt_i2c_bus_device_find(const char *bus_name)
|
|
|
{
|
|
|
- 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)
|
|
|
+ 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)
|
|
|
{
|
|
|
- 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;
|
|
|
- }
|
|
|
+ i2c_dbg("I2C bus %s not exist\n", bus_name);
|
|
|
+ return RT_NULL;
|
|
|
}
|
|
|
-
|
|
|
- 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;
|
|
|
- }
|
|
|
- }
|
|
|
+ bus = (struct rt_i2c_bus_device *)dev->user_data;
|
|
|
|
|
|
- return RT_EOK;
|
|
|
+ return bus;
|
|
|
}
|
|
|
|
|
|
-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 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 < size; ret++)
|
|
|
+ #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
|
|
|
+ #endif
|
|
|
|
|
|
rt_mutex_take(&bus->lock, RT_WAITING_FOREVER);
|
|
|
-
|
|
|
- ret = bus->ops->master_xfer(bus, msgs, size);
|
|
|
+ ret = bus->ops->master_xfer(bus, msgs, num);
|
|
|
rt_mutex_release(&bus->lock);
|
|
|
|
|
|
return ret;
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
- rt_kprintf("I2C bus transfers not supported\n");
|
|
|
+ rt_kprintf("I2C bus operation 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 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;
|
|
|
- struct rt_i2c_bus *bus = device->bus;
|
|
|
|
|
|
- msg.addr = device->addr;
|
|
|
- msg.flags = device->flags & RT_I2C_ADDR_10BIT;
|
|
|
- msg.len = size;
|
|
|
+ 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);
|
|
|
|
|
|
- if (ret > 0)
|
|
|
- {
|
|
|
- return size;
|
|
|
- }
|
|
|
-
|
|
|
- return ret;
|
|
|
+ return (ret > 0) ? count : ret;
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
-rt_size_t rt_i2c_master_recv(struct rt_i2c_device *device,
|
|
|
- rt_uint8_t *buf, rt_uint32_t size)
|
|
|
+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;
|
|
|
- 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.addr = addr;
|
|
|
+ msg.flags = flags & RT_I2C_ADDR_10BIT;
|
|
|
msg.flags |= RT_I2C_RD;
|
|
|
- msg.len = size;
|
|
|
+ msg.len = count;
|
|
|
msg.buf = buf;
|
|
|
|
|
|
ret = rt_i2c_transfer(bus, &msg, 1);
|
|
|
|
|
|
- if (ret > 0)
|
|
|
- {
|
|
|
- return size;
|
|
|
- }
|
|
|
-
|
|
|
- return ret;
|
|
|
+ return (ret > 0) ? count : ret;
|
|
|
}
|
|
|
|
|
|
|
|
|
-rt_err_t rt_i2c_core_init()
|
|
|
+rt_err_t rt_i2c_core_init(void)
|
|
|
{
|
|
|
+
|
|
|
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);
|
|
|
+
|
|
|
}
|
|
|
|
luohui2320@gmail.com