libs/rt-thread-official
libs
/
rt-thread-official
mirror of https://github.com/RT-Thread/rt-thread.git
4
0
Fork 0
Code Issues Releases Wiki Activity

fixed a eclipse compiling warning. 

git-svn-id: https://rt-thread.googlecode.com/svn/trunk@2163 bbd45198-f89e-11dd-88c7-29a3b14d5316
This commit is contained in:
wuyangyong 2012-06-14 12:18:52 +00:00
parent 72bce28791
commit 9e3c72a635
7 changed files with 914 additions and 871 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

888
components/drivers/i2c/i2c-bit-ops.c
View File

@ -1,444 +1,444 @@
/* /*
* File : i2c-bit-ops.c * File : i2c-bit-ops.c
* This file is part of RT-Thread RTOS * This file is part of RT-Thread RTOS
* COPYRIGHT (C) 2006, RT-Thread Development Team * COPYRIGHT (C) 2006, RT-Thread Development Team
* *
* The license and distribution terms for this file may be * The license and distribution terms for this file may be
* found in the file LICENSE in this distribution or at * found in the file LICENSE in this distribution or at
* http://www.rt-thread.org/license/LICENSE * http://www.rt-thread.org/license/LICENSE
* *
* Change Logs: * Change Logs:
* Date Author Notes * Date Author Notes
* 2012-04-25 weety first version * 2012-04-25 weety first version
*/ */
#include <rtdevice.h> #include <rtdevice.h>
#ifdef RT_I2C_BIT_DEBUG #ifdef RT_I2C_BIT_DEBUG
#define bit_dbg(fmt, ...) rt_kprintf(fmt, ##__VA_ARGS__) #define bit_dbg(fmt, ...) rt_kprintf(fmt, ##__VA_ARGS__)
#else #else
#define bit_dbg(fmt, ...) #define bit_dbg(fmt, ...)
#endif #endif
#define SET_SDA(ops, val) ops->set_sda(ops->data, val) #define SET_SDA(ops, val) ops->set_sda(ops->data, val)
#define SET_SCL(ops, val) ops->set_scl(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_SDA(ops) ops->get_sda(ops->data)
#define GET_SCL(ops) ops->get_scl(ops->data) #define GET_SCL(ops) ops->get_scl(ops->data)
rt_inline void i2c_delay(struct rt_i2c_bit_ops *ops) rt_inline void i2c_delay(struct rt_i2c_bit_ops *ops)
{ {
ops->udelay((ops->delay_us + 1) >> 1); ops->udelay((ops->delay_us + 1) >> 1);
} }
rt_inline void i2c_delay2(struct rt_i2c_bit_ops *ops) rt_inline void i2c_delay2(struct rt_i2c_bit_ops *ops)
{ {
ops->udelay(ops->delay_us); ops->udelay(ops->delay_us);
} }
#define SDA_L(ops) SET_SDA(ops, 0) #define SDA_L(ops) SET_SDA(ops, 0)
#define SDA_H(ops) SET_SDA(ops, 1) #define SDA_H(ops) SET_SDA(ops, 1)
#define SCL_L(ops) SET_SCL(ops, 0) #define SCL_L(ops) SET_SCL(ops, 0)
/* /*
* release scl line, and wait scl line to high. * release scl line, and wait scl line to high.
*/ */
static rt_err_t SCL_H(struct rt_i2c_bit_ops *ops) static rt_err_t SCL_H(struct rt_i2c_bit_ops *ops)
{ {
rt_tick_t start; rt_tick_t start;
SET_SCL(ops, 1); SET_SCL(ops, 1);
if (!ops->get_scl) if (!ops->get_scl)
goto done; goto done;
start = rt_tick_get(); start = rt_tick_get();
while (!GET_SCL(ops)) while (!GET_SCL(ops))
{ {
if ((rt_tick_get() - start) > ops->timeout) if ((rt_tick_get() - start) > ops->timeout)
return -RT_ETIMEOUT; return -RT_ETIMEOUT;
rt_thread_delay((ops->timeout + 1) >> 1); rt_thread_delay((ops->timeout + 1) >> 1);
} }
#ifdef RT_I2C_BIT_DEBUG #ifdef RT_I2C_BIT_DEBUG
if (rt_tick_get() != start) if (rt_tick_get() != start)
{ {
bit_dbg("wait %ld tick for SCL line to go high\n", bit_dbg("wait %ld tick for SCL line to go high\n",
rt_tick_get() - start); rt_tick_get() - start);
} }
#endif #endif
done: done:
i2c_delay(ops); i2c_delay(ops);
return RT_EOK; return RT_EOK;
} }
static void i2c_start(struct rt_i2c_bit_ops *ops) static void i2c_start(struct rt_i2c_bit_ops *ops)
{ {
#ifdef RT_I2C_BIT_DEBUG #ifdef RT_I2C_BIT_DEBUG
if (ops->get_scl && !GET_SCL(ops)) if (ops->get_scl && !GET_SCL(ops))
{ {
bit_dbg("I2C bus error, SCL line low\n"); bit_dbg("I2C bus error, SCL line low\n");
} }
if (ops->get_sda && !GET_SDA(ops)) if (ops->get_sda && !GET_SDA(ops))
{ {
bit_dbg("I2C bus error, SDA line low\n"); bit_dbg("I2C bus error, SDA line low\n");
} }
#endif #endif
SDA_L(ops); SDA_L(ops);
i2c_delay(ops); i2c_delay(ops);
SCL_L(ops); SCL_L(ops);
} }
static void i2c_restart(struct rt_i2c_bit_ops *ops) static void i2c_restart(struct rt_i2c_bit_ops *ops)
{ {
SDA_H(ops); SDA_H(ops);
SCL_H(ops); SCL_H(ops);
i2c_delay(ops); i2c_delay(ops);
SDA_L(ops); SDA_L(ops);
i2c_delay(ops); i2c_delay(ops);
SCL_L(ops); SCL_L(ops);
} }
static void i2c_stop(struct rt_i2c_bit_ops *ops) static void i2c_stop(struct rt_i2c_bit_ops *ops)
{ {
SDA_L(ops); SDA_L(ops);
i2c_delay(ops); i2c_delay(ops);
SCL_H(ops); SCL_H(ops);
i2c_delay(ops); i2c_delay(ops);
SDA_H(ops); SDA_H(ops);
i2c_delay2(ops); i2c_delay2(ops);
} }
rt_inline rt_bool_t i2c_waitack(struct rt_i2c_bit_ops *ops) rt_inline rt_bool_t i2c_waitack(struct rt_i2c_bit_ops *ops)
{ {
rt_bool_t ack; rt_bool_t ack;
SDA_H(ops); SDA_H(ops);
i2c_delay(ops); i2c_delay(ops);
if (SCL_H(ops) < 0) if (SCL_H(ops) < 0)
{ {
bit_dbg("wait ack timeout\n"); bit_dbg("wait ack timeout\n");
return -RT_ETIMEOUT; return -RT_ETIMEOUT;
} }
ack = !GET_SDA(ops); /* ACK : SDA pin is pulled low */ ack = !GET_SDA(ops); /* ACK : SDA pin is pulled low */
bit_dbg("%s\n", ack ? "ACK" : "NACK"); bit_dbg("%s\n", ack ? "ACK" : "NACK");
SCL_L(ops); SCL_L(ops);
return ack; return ack;
} }
static rt_int32_t i2c_writeb(struct rt_i2c_bus_device *bus, rt_uint8_t data) static rt_int32_t i2c_writeb(struct rt_i2c_bus_device *bus, rt_uint8_t data)
{ {
rt_int32_t i; rt_int32_t i;
rt_uint8_t bit; rt_uint8_t bit;
struct rt_i2c_bit_ops *ops = bus->priv; struct rt_i2c_bit_ops *ops = bus->priv;
for (i = 7; i >= 0; i--) for (i = 7; i >= 0; i--)
{ {
SCL_L(ops); SCL_L(ops);
bit = (data >> i) & 1; bit = (data >> i) & 1;
SET_SDA(ops, bit); SET_SDA(ops, bit);
i2c_delay(ops); i2c_delay(ops);
if (SCL_H(ops) < 0) if (SCL_H(ops) < 0)
{ {
bit_dbg("i2c_writeb: 0x%02x, " bit_dbg("i2c_writeb: 0x%02x, "
"wait scl pin high timeout at bit %d\n", "wait scl pin high timeout at bit %d\n",
data, i); data, i);
return -RT_ETIMEOUT; return -RT_ETIMEOUT;
} }
} }
SCL_L(ops); SCL_L(ops);
i2c_delay(ops); i2c_delay(ops);
return i2c_waitack(ops); return i2c_waitack(ops);
} }
static rt_int32_t i2c_readb(struct rt_i2c_bus_device *bus) static rt_int32_t i2c_readb(struct rt_i2c_bus_device *bus)
{ {
rt_uint8_t i; rt_uint8_t i;
rt_uint8_t data = 0; rt_uint8_t data = 0;
struct rt_i2c_bit_ops *ops = bus->priv; struct rt_i2c_bit_ops *ops = bus->priv;
SDA_H(ops); SDA_H(ops);
i2c_delay(ops); i2c_delay(ops);
for (i = 0; i < 8; i++) for (i = 0; i < 8; i++)
{ {
data <<= 1; data <<= 1;
if (SCL_H(ops) < 0) if (SCL_H(ops) < 0)
{ {
bit_dbg("i2c_readb: wait scl pin high " bit_dbg("i2c_readb: wait scl pin high "
"timeout at bit %d\n", 7 - i); "timeout at bit %d\n", 7 - i);
return -RT_ETIMEOUT; return -RT_ETIMEOUT;
} }
if (GET_SDA(ops)) if (GET_SDA(ops))
data |= 1; data |= 1;
SCL_L(ops); SCL_L(ops);
i2c_delay2(ops); i2c_delay2(ops);
} }
return data; return data;
} }
static rt_size_t i2c_send_bytes(struct rt_i2c_bus_device *bus, struct rt_i2c_msg *msg) static rt_size_t i2c_send_bytes(struct rt_i2c_bus_device *bus, struct rt_i2c_msg *msg)
{ {
rt_int32_t ret; rt_int32_t ret;
rt_size_t bytes = 0; rt_size_t bytes = 0;
const rt_uint8_t *ptr = msg->buf; const rt_uint8_t *ptr = msg->buf;
rt_int32_t count = msg->len; rt_int32_t count = msg->len;
rt_uint16_t ignore_nack = msg->flags & RT_I2C_IGNORE_NACK; rt_uint16_t ignore_nack = msg->flags & RT_I2C_IGNORE_NACK;
while (count > 0) while (count > 0)
{ {
ret = i2c_writeb(bus, *ptr); ret = i2c_writeb(bus, *ptr);
if ((ret > 0) || (ignore_nack && (ret == 0))) if ((ret > 0) || (ignore_nack && (ret == 0)))
{ {
count--; count--;
ptr++; ptr++;
bytes++; bytes++;
} }
else if (ret == 0) else if (ret == 0)
{ {
rt_kprintf("send bytes: NACK.\n"); i2c_dbg("send bytes: NACK.\n");
return -RT_ERROR; return 0;
} }
else else
{ {
rt_kprintf("send bytes: error %d\n", ret); i2c_dbg("send bytes: error %d\n", ret);
return ret; return ret;
} }
} }
return bytes; return bytes;
} }
static rt_err_t i2c_send_ack_or_nack(struct rt_i2c_bus_device *bus, int ack) 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; struct rt_i2c_bit_ops *ops = bus->priv;
if (ack) if (ack)
SET_SDA(ops, 0); SET_SDA(ops, 0);
i2c_delay(ops); i2c_delay(ops);
if (SCL_H(ops) < 0) if (SCL_H(ops) < 0)
{ {
rt_kprintf("ACK or NACK timeout\n"); bit_dbg("ACK or NACK timeout\n");
return -RT_ETIMEOUT; return -RT_ETIMEOUT;
} }
SCL_L(ops); SCL_L(ops);
return RT_EOK; return RT_EOK;
} }
static rt_size_t i2c_recv_bytes(struct rt_i2c_bus_device *bus, struct rt_i2c_msg *msg) 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 val;
rt_int32_t bytes = 0; /* actual bytes */ rt_int32_t bytes = 0; /* actual bytes */
rt_uint8_t *ptr = msg->buf; rt_uint8_t *ptr = msg->buf;
rt_int32_t count = msg->len; rt_int32_t count = msg->len;
const rt_uint32_t flags = msg->flags; const rt_uint32_t flags = msg->flags;
while (count > 0) while (count > 0)
{ {
val = i2c_readb(bus); val = i2c_readb(bus);
if (val >= 0) if (val >= 0)
{ {
*ptr = val; *ptr = val;
bytes++; bytes++;
} }
else else
{ {
break; break;
} }
ptr++; ptr++;
count--; count--;
bit_dbg("recieve bytes: 0x%02x, %s\n", bit_dbg("recieve bytes: 0x%02x, %s\n",
val, (flags & RT_I2C_NO_READ_ACK) ? val, (flags & RT_I2C_NO_READ_ACK) ?
"(No ACK/NACK)" : (count ? "ACK" : "NACK")); "(No ACK/NACK)" : (count ? "ACK" : "NACK"));
if (!(flags & RT_I2C_NO_READ_ACK)) if (!(flags & RT_I2C_NO_READ_ACK))
{ {
val = i2c_send_ack_or_nack(bus, count); val = i2c_send_ack_or_nack(bus, count);
if (val < 0) if (val < 0)
return val; return val;
} }
} }
return bytes; return bytes;
} }
static rt_int32_t i2c_send_address(struct rt_i2c_bus_device *bus, static rt_int32_t i2c_send_address(struct rt_i2c_bus_device *bus,
rt_uint8_t addr, rt_int32_t retries) rt_uint8_t addr, rt_int32_t retries)
{ {
struct rt_i2c_bit_ops *ops = bus->priv; struct rt_i2c_bit_ops *ops = bus->priv;
rt_int32_t i; rt_int32_t i;
rt_err_t ret = 0; rt_err_t ret = 0;
for (i = 0; i <= retries; i++) for (i = 0; i <= retries; i++)
{ {
ret = i2c_writeb(bus, addr); ret = i2c_writeb(bus, addr);
if (ret == 1 || i == retries) if (ret == 1 || i == retries)
break; break;
bit_dbg("send stop condition\n"); bit_dbg("send stop condition\n");
i2c_stop(ops); i2c_stop(ops);
i2c_delay2(ops); i2c_delay2(ops);
bit_dbg("send start condition\n"); bit_dbg("send start condition\n");
i2c_start(ops); i2c_start(ops);
} }
return ret; return ret;
} }
static rt_err_t i2c_bit_send_address(struct rt_i2c_bus_device *bus, struct rt_i2c_msg *msg) 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 flags = msg->flags;
rt_uint16_t ignore_nack = msg->flags & RT_I2C_IGNORE_NACK; rt_uint16_t ignore_nack = msg->flags & RT_I2C_IGNORE_NACK;
struct rt_i2c_bit_ops *ops = bus->priv; struct rt_i2c_bit_ops *ops = bus->priv;
rt_uint8_t addr1, addr2; rt_uint8_t addr1, addr2;
rt_int32_t retries; rt_int32_t retries;
rt_err_t ret; rt_err_t ret;
retries = ignore_nack ? 0 : bus->retries; retries = ignore_nack ? 0 : bus->retries;
if (flags & RT_I2C_ADDR_10BIT) if (flags & RT_I2C_ADDR_10BIT)
{ {
addr1 = 0xf0 | ((msg->addr >> 7) & 0x06); addr1 = 0xf0 | ((msg->addr >> 7) & 0x06);
addr2 = msg->addr & 0xff; addr2 = msg->addr & 0xff;
bit_dbg("addr1: %d, addr2: %d\n", addr1, addr2); bit_dbg("addr1: %d, addr2: %d\n", addr1, addr2);
ret = i2c_send_address(bus, addr1, retries); ret = i2c_send_address(bus, addr1, retries);
if ((ret != 1) && !ignore_nack) if ((ret != 1) && !ignore_nack)
{ {
rt_kprintf("NACK: sending first addr\n"); bit_dbg("NACK: sending first addr\n");
return -RT_EIO; return -RT_EIO;
} }
ret = i2c_writeb(bus, addr2); ret = i2c_writeb(bus, addr2);
if ((ret != 1) && !ignore_nack) if ((ret != 1) && !ignore_nack)
{ {
rt_kprintf("NACK: sending second addr\n"); bit_dbg("NACK: sending second addr\n");
return -RT_EIO; return -RT_EIO;
} }
if (flags & RT_I2C_RD) if (flags & RT_I2C_RD)
{ {
bit_dbg("send repeated start condition\n"); bit_dbg("send repeated start condition\n");
i2c_restart(ops); i2c_restart(ops);
addr1 |= 0x01; addr1 |= 0x01;
ret = i2c_send_address(bus, addr1, retries); ret = i2c_send_address(bus, addr1, retries);
if ((ret != 1) && !ignore_nack) if ((ret != 1) && !ignore_nack)
{ {
rt_kprintf("NACK: sending repeated addr\n"); bit_dbg("NACK: sending repeated addr\n");
return -RT_EIO; return -RT_EIO;
} }
} }
} }
else else
{ /* 7-bit addr */ {
addr1 = msg->addr << 1; /* 7-bit addr */
if (flags & RT_I2C_RD) addr1 = msg->addr << 1;
addr1 |= 1; if (flags & RT_I2C_RD)
ret = i2c_send_address(bus, addr1, retries); addr1 |= 1;
if ((ret != 1) && !ignore_nack) ret = i2c_send_address(bus, addr1, retries);
return -RT_EIO; if ((ret != 1) && !ignore_nack)
} return -RT_EIO;
}
return RT_EOK;
} 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) 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; struct rt_i2c_msg *msg;
rt_int32_t i, ret; struct rt_i2c_bit_ops *ops = bus->priv;
rt_uint16_t ignore_nack; rt_int32_t i, ret;
rt_uint16_t ignore_nack;
bit_dbg("send start condition\n");
i2c_start(ops); bit_dbg("send start condition\n");
for (i = 0; i < num; i++) i2c_start(ops);
{ for (i = 0; i < num; i++)
msg = &msgs[i]; {
ignore_nack = msg->flags & RT_I2C_IGNORE_NACK; msg = &msgs[i];
if (!(msg->flags & RT_I2C_NO_START)) ignore_nack = msg->flags & RT_I2C_IGNORE_NACK;
{ if (!(msg->flags & RT_I2C_NO_START))
if (i) {
{ if (i)
i2c_restart(ops); {
} i2c_restart(ops);
ret = i2c_bit_send_address(bus, msg); }
if ((ret != RT_EOK) && !ignore_nack) 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); bit_dbg("receive NACK from device addr 0x%02x msg %d\n",
goto out; msgs[i].addr, i);
} goto out;
} }
if (msg->flags & RT_I2C_RD) }
{ if (msg->flags & RT_I2C_RD)
ret = i2c_recv_bytes(bus, msg); {
if (ret >= 1) ret = i2c_recv_bytes(bus, msg);
bit_dbg("read %d byte%s\n", if (ret >= 1)
ret, ret == 1 ? "" : "s"); bit_dbg("read %d byte%s\n",
if (ret < msg->len) ret, ret == 1 ? "" : "s");
{ if (ret < msg->len)
if (ret >= 0) {
ret = -RT_EIO; if (ret >= 0)
goto out; ret = -RT_EIO;
} goto out;
} }
else }
{ else
ret = i2c_send_bytes(bus, msg); {
if (ret >= 1) ret = i2c_send_bytes(bus, msg);
bit_dbg("write %d byte%s\n", if (ret >= 1)
ret, ret == 1 ? "" : "s"); bit_dbg("write %d byte%s\n",
if (ret < msg->len) ret, ret == 1 ? "" : "s");
{ if (ret < msg->len)
if (ret >= 0) {
ret = -RT_ERROR; if (ret >= 0)
goto out; ret = -RT_ERROR;
} goto out;
} }
} }
ret = i; }
ret = i;
out:
bit_dbg("send stop condition\n"); out:
i2c_stop(ops); bit_dbg("send stop condition\n");
i2c_stop(ops);
return ret;
} return ret;
}
static const struct rt_i2c_bus_device_ops i2c_bit_bus_ops = {
i2c_bit_xfer, static const struct rt_i2c_bus_device_ops i2c_bit_bus_ops =
RT_NULL, {
RT_NULL 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; 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; struct rt_i2c_bit_ops *bit_ops = bus->priv;
RT_ASSERT(bit_ops != RT_NULL); RT_ASSERT(bit_ops != RT_NULL);
bus->ops = &i2c_bit_bus_ops; bus->ops = &i2c_bit_bus_ops;
return rt_i2c_bus_device_register(bus, bus_name); return rt_i2c_bus_device_register(bus, bus_name);
} }

264
components/drivers/i2c/i2c_core.c
View File

@ -1,129 +1,135 @@
/* /*
* File : i2c_core.c * File : i2c_core.c
* This file is part of RT-Thread RTOS * This file is part of RT-Thread RTOS
* COPYRIGHT (C) 2006, RT-Thread Development Team * COPYRIGHT (C) 2006, RT-Thread Development Team
* *
* The license and distribution terms for this file may be * The license and distribution terms for this file may be
* found in the file LICENSE in this distribution or at * found in the file LICENSE in this distribution or at
* http://www.rt-thread.org/license/LICENSE * http://www.rt-thread.org/license/LICENSE
* *
* Change Logs: * Change Logs:
* Date Author Notes * Date Author Notes
* 2012-04-25 weety first version * 2012-04-25 weety first version
*/ */
#include <rtdevice.h> #include <rtdevice.h>
static struct rt_mutex i2c_core_lock; 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 rt_i2c_bus_device_register(struct rt_i2c_bus_device *bus,
{ const char *bus_name)
rt_err_t res = RT_EOK; {
rt_err_t res = RT_EOK;
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);
rt_mutex_take(&i2c_core_lock, RT_WAITING_FOREVER);
if (bus->timeout == 0)
bus->timeout = RT_TICK_PER_SECOND; if (bus->timeout == 0)
bus->timeout = RT_TICK_PER_SECOND;
res = rt_i2c_bus_device_device_init(bus, bus_name);
res = rt_i2c_bus_device_device_init(bus, bus_name);
i2c_dbg("I2C bus [%s] registered\n", bus_name);
i2c_dbg("I2C bus [%s] registered\n", bus_name);
rt_mutex_release(&i2c_core_lock);
return res; 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* rt_i2c_bus_device_find(const char *bus_name)
struct rt_i2c_bus_device *bus; {
rt_device_t dev = rt_device_find(bus_name); struct rt_i2c_bus_device *bus;
if (dev == RT_NULL || dev->type != RT_Device_Class_I2CBUS) 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; i2c_dbg("I2C bus %s not exist\n", bus_name);
} return RT_NULL;
}
bus = (struct rt_i2c_bus_device *)dev->user_data;
bus = (struct rt_i2c_bus_device *)dev->user_data;
return bus;
} 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 rt_i2c_transfer(struct rt_i2c_bus_device *bus,
rt_size_t ret; struct rt_i2c_msg msgs[],
rt_uint32_t num)
if (bus->ops->master_xfer) {
{ rt_size_t ret;
#ifdef RT_I2C_DEBUG
for (ret = 0; ret < num; ret++) if (bus->ops->master_xfer)
{ {
i2c_dbg("msgs[%d] %c, addr=0x%02x, len=%d%s\n", ret, #ifdef RT_I2C_DEBUG
(msgs[ret].flags & RT_I2C_RD) ? 'R' : 'W', for (ret = 0; ret < num; ret++)
msgs[ret].addr, msgs[ret].len); {
} i2c_dbg("msgs[%d] %c, addr=0x%02x, len=%d%s\n", ret,
#endif (msgs[ret].flags & RT_I2C_RD) ? 'R' : 'W',
msgs[ret].addr, msgs[ret].len);
rt_mutex_take(&bus->lock, RT_WAITING_FOREVER); }
ret = bus->ops->master_xfer(bus, msgs, num); #endif
rt_mutex_release(&bus->lock);
rt_mutex_take(&bus->lock, RT_WAITING_FOREVER);
return ret; ret = bus->ops->master_xfer(bus, msgs, num);
} rt_mutex_release(&bus->lock);
else
{ return ret;
rt_kprintf("I2C bus operation not supported\n"); }
return -RT_ERROR; 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 rt_i2c_master_send(struct rt_i2c_bus_device *bus,
rt_size_t ret; rt_uint16_t addr,
struct rt_i2c_msg msg; rt_uint16_t flags,
const rt_uint8_t *buf,
msg.addr = addr; rt_uint32_t count)
msg.flags = flags & RT_I2C_ADDR_10BIT; {
msg.len = count; rt_size_t ret;
msg.buf = (rt_uint8_t *)buf; struct rt_i2c_msg msg;
ret = rt_i2c_transfer(bus, &msg, 1); msg.addr = addr;
msg.flags = flags & RT_I2C_ADDR_10BIT;
return (ret > 0) ? count : ret; msg.len = count;
} msg.buf = (rt_uint8_t *)buf;
ret = rt_i2c_transfer(bus, &msg, 1);
rt_size_t rt_i2c_master_recv(struct rt_i2c_bus_device *bus, rt_uint16_t addr, return (ret > 0) ? count : ret;
rt_uint16_t flags, rt_uint8_t *buf, }
rt_uint32_t count)
{
rt_size_t ret;
struct rt_i2c_msg msg; rt_size_t rt_i2c_master_recv(struct rt_i2c_bus_device *bus,
RT_ASSERT(bus != RT_NULL); rt_uint16_t addr,
rt_uint16_t flags,
msg.addr = addr; rt_uint8_t *buf,
msg.flags = flags & RT_I2C_ADDR_10BIT; rt_uint32_t count)
msg.flags |= RT_I2C_RD; {
msg.len = count; rt_size_t ret;
msg.buf = buf; struct rt_i2c_msg msg;
RT_ASSERT(bus != RT_NULL);
ret = rt_i2c_transfer(bus, &msg, 1);
msg.addr = addr;
return (ret > 0) ? count : ret; msg.flags = flags & RT_I2C_ADDR_10BIT;
} msg.flags |= RT_I2C_RD;
msg.len = count;
msg.buf = buf;
rt_err_t rt_i2c_core_init(void)
{ ret = rt_i2c_transfer(bus, &msg, 1);
rt_mutex_init (&i2c_core_lock, "i2c_core_lock", RT_IPC_FLAG_FIFO); 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);
}

152
components/drivers/i2c/i2c_dev.c
View File

@ -1,105 +1,113 @@
#include <rtdevice.h> #include <rtdevice.h>
static rt_err_t i2c_bus_device_init(rt_device_t dev) 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; struct rt_i2c_bus_device* bus = (struct rt_i2c_bus_device *)dev->user_data;
RT_ASSERT(bus != RT_NULL); 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 addr;
rt_uint16_t flags; rt_uint16_t flags;
struct rt_i2c_bus_device* bus = (struct rt_i2c_bus_device *)dev->user_data; struct rt_i2c_bus_device* bus = (struct rt_i2c_bus_device *)dev->user_data;
RT_ASSERT(bus != RT_NULL);
RT_ASSERT(buffer != RT_NULL);
i2c_dbg("I2C bus dev [%s] reading %u bytes.\n", dev->parent.name, count); RT_ASSERT(bus != RT_NULL);
RT_ASSERT(buffer != RT_NULL);
addr = pos & 0xffff; i2c_dbg("I2C bus dev [%s] reading %u bytes.\n", dev->parent.name, count);
flags = (pos >> 16) & 0xffff;
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 addr;
rt_uint16_t flags; rt_uint16_t flags;
struct rt_i2c_bus_device* bus = (struct rt_i2c_bus_device *)dev->user_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);
RT_ASSERT(buffer != 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; addr = pos & 0xffff;
flags = (pos >> 16) & 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; rt_err_t ret;
struct rt_i2c_priv_data *priv_data; struct rt_i2c_priv_data *priv_data;
struct rt_i2c_bus_device* bus = (struct rt_i2c_bus_device *)dev->user_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) switch (cmd)
{ {
case RT_I2C_DEV_CTRL_10BIT: /* set 10-bit addr mode */ case RT_I2C_DEV_CTRL_10BIT: /* set 10-bit addr mode */
bus->flags |= RT_I2C_ADDR_10BIT; bus->flags |= RT_I2C_ADDR_10BIT;
break; break;
case RT_I2C_DEV_CTRL_ADDR: case RT_I2C_DEV_CTRL_ADDR:
bus->addr = *(rt_uint16_t *)args; bus->addr = *(rt_uint16_t *)args;
break; break;
case RT_I2C_DEV_CTRL_TIMEOUT: case RT_I2C_DEV_CTRL_TIMEOUT:
bus->timeout = *(rt_uint32_t *)args; bus->timeout = *(rt_uint32_t *)args;
break; break;
case RT_I2C_DEV_CTRL_RW: case RT_I2C_DEV_CTRL_RW:
priv_data = (struct rt_i2c_priv_data *)args; priv_data = (struct rt_i2c_priv_data *)args;
ret = rt_i2c_transfer(bus, priv_data->msgs, priv_data->number); ret = rt_i2c_transfer(bus, priv_data->msgs, priv_data->number);
if (ret < 0) if (ret < 0)
{ {
return -RT_EIO; return -RT_EIO;
} }
break; break;
default: 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; struct rt_device *device;
RT_ASSERT(bus != RT_NULL); RT_ASSERT(bus != RT_NULL);
device = &bus->parent; device = &bus->parent;
device->user_data = bus;
/* set device type */ device->user_data = bus;
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 */ /* set device type */
rt_device_register(device, name, RT_DEVICE_FLAG_RDWR); 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;
return RT_EOK; /* register to device manager */
rt_device_register(device, name, RT_DEVICE_FLAG_RDWR);
return RT_EOK;
} }

84
components/drivers/include/drivers/i2c-bit-ops.h
View File

@ -1,41 +1,43 @@
/* /*
* File : i2c-bit-ops.h * File : i2c-bit-ops.h
* This file is part of RT-Thread RTOS * This file is part of RT-Thread RTOS
* COPYRIGHT (C) 2006, RT-Thread Development Team * COPYRIGHT (C) 2006, RT-Thread Development Team
* *
* The license and distribution terms for this file may be * The license and distribution terms for this file may be
* found in the file LICENSE in this distribution or at * found in the file LICENSE in this distribution or at
* http://www.rt-thread.org/license/LICENSE * http://www.rt-thread.org/license/LICENSE
* *
* Change Logs: * Change Logs:
* Date Author Notes * Date Author Notes
* 2012-04-25 weety first version * 2012-04-25 weety first version
*/ */
#ifndef __I2C_BIT_OPS_H__ #ifndef __I2C_BIT_OPS_H__
#define __I2C_BIT_OPS_H__ #define __I2C_BIT_OPS_H__
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
struct rt_i2c_bit_ops { struct rt_i2c_bit_ops
void *data; /* private data for lowlevel routines */ {
void (*set_sda) (void *data, rt_int32_t state); void *data; /* private data for lowlevel routines */
void (*set_scl) (void *data, rt_int32_t state); void (*set_sda) (void *data, rt_int32_t state);
rt_int32_t (*get_sda) (void *data); void (*set_scl) (void *data, rt_int32_t state);
rt_int32_t (*get_scl) (void *data); rt_int32_t (*get_sda) (void *data);
rt_int32_t (*get_scl) (void *data);
void (*udelay) (rt_uint32_t us);
void (*udelay) (rt_uint32_t us);
rt_uint32_t delay_us; /* scl and sda line delay */
rt_uint32_t timeout; /* in tick */ 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);
rt_err_t rt_i2c_bit_add_bus(struct rt_i2c_bus_device *bus,
#ifdef __cplusplus const char *bus_name);
}
#endif #ifdef __cplusplus
}
#endif #endif
#endif

174
components/drivers/include/drivers/i2c.h
View File

@ -1,79 +1,95 @@
/* /*
* File : i2c.h * File : i2c.h
* This file is part of RT-Thread RTOS * This file is part of RT-Thread RTOS
* COPYRIGHT (C) 2006, RT-Thread Development Team * COPYRIGHT (C) 2006, RT-Thread Development Team
* *
* The license and distribution terms for this file may be * The license and distribution terms for this file may be
* found in the file LICENSE in this distribution or at * found in the file LICENSE in this distribution or at
* http://www.rt-thread.org/license/LICENSE * http://www.rt-thread.org/license/LICENSE
* *
* Change Logs: * Change Logs:
* Date Author Notes * Date Author Notes
* 2012-04-25 weety first version * 2012-04-25 weety first version
*/ */
#ifndef __I2C_H__ #ifndef __I2C_H__
#define __I2C_H__ #define __I2C_H__
#include <rtthread.h> #include <rtthread.h>
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
#define RT_I2C_WR 0x0000 #define RT_I2C_WR 0x0000
#define RT_I2C_RD (1u << 0) #define RT_I2C_RD (1u << 0)
#define RT_I2C_ADDR_10BIT (1u << 2) /* this is a ten bit chip address */ #define RT_I2C_ADDR_10BIT (1u << 2) /* this is a ten bit chip address */
#define RT_I2C_NO_START (1u << 4) #define RT_I2C_NO_START (1u << 4)
#define RT_I2C_IGNORE_NACK (1u << 5) #define RT_I2C_IGNORE_NACK (1u << 5)
#define RT_I2C_NO_READ_ACK (1u << 6) /* when I2C reading, we do not ACK */ #define RT_I2C_NO_READ_ACK (1u << 6) /* when I2C reading, we do not ACK */
struct rt_i2c_msg { struct rt_i2c_msg
rt_uint16_t addr; {
rt_uint16_t flags; rt_uint16_t addr;
rt_uint16_t len; rt_uint16_t flags;
rt_uint8_t *buf; rt_uint16_t len;
}; rt_uint8_t *buf;
};
struct rt_i2c_bus_device;
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); struct rt_i2c_bus_device_ops
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); rt_size_t (*master_xfer) (struct rt_i2c_bus_device *bus,
}; struct rt_i2c_msg msgs[],
rt_uint32_t num);
/*for i2c bus driver*/ rt_size_t (*slave_xfer) (struct rt_i2c_bus_device *bus,
struct rt_i2c_bus_device { struct rt_i2c_msg msgs[],
struct rt_device parent; rt_uint32_t num);
const struct rt_i2c_bus_device_ops *ops; rt_err_t (*i2c_bus_control) (struct rt_i2c_bus_device *bus,
rt_uint16_t flags; rt_uint32_t,
rt_uint16_t addr; rt_uint32_t);
struct rt_mutex lock; };
rt_uint32_t timeout;
rt_uint32_t retries; /*for i2c bus driver*/
void *priv; struct rt_i2c_bus_device
}; {
struct rt_device parent;
#ifdef RT_I2C_DEBUG const struct rt_i2c_bus_device_ops *ops;
#define i2c_dbg(fmt, ...) rt_kprintf(fmt, ##__VA_ARGS__) rt_uint16_t flags;
#else rt_uint16_t addr;
#define i2c_dbg(fmt, ...) struct rt_mutex lock;
#endif rt_uint32_t timeout;
rt_uint32_t retries;
rt_err_t rt_i2c_bus_device_register(struct rt_i2c_bus_device *bus, const char *bus_name); void *priv;
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, #ifdef RT_I2C_DEBUG
rt_uint16_t flags, const rt_uint8_t *buf, #define i2c_dbg(fmt, ...) rt_kprintf(fmt, ##__VA_ARGS__)
rt_uint32_t count); #else
rt_size_t rt_i2c_master_recv(struct rt_i2c_bus_device *bus, rt_uint16_t addr, #define i2c_dbg(fmt, ...)
rt_uint16_t flags, rt_uint8_t *buf, #endif
rt_uint32_t count);
rt_err_t rt_i2c_core_init(void); rt_err_t rt_i2c_bus_device_register(struct rt_i2c_bus_device *bus,
const char *bus_name);
#ifdef __cplusplus 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,
#endif struct rt_i2c_msg msgs[],
rt_uint32_t num);
#endif 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

56
components/drivers/include/drivers/i2c_dev.h
View File

@ -1,27 +1,29 @@
#ifndef __I2C_DEV_H__ #ifndef __I2C_DEV_H__
#define __I2C_DEV_H__ #define __I2C_DEV_H__
#include <rtthread.h> #include <rtthread.h>
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
#define RT_I2C_DEV_CTRL_10BIT 0x20 #define RT_I2C_DEV_CTRL_10BIT 0x20
#define RT_I2C_DEV_CTRL_ADDR 0x21 #define RT_I2C_DEV_CTRL_ADDR 0x21
#define RT_I2C_DEV_CTRL_TIMEOUT 0x22 #define RT_I2C_DEV_CTRL_TIMEOUT 0x22
#define RT_I2C_DEV_CTRL_RW 0x23 #define RT_I2C_DEV_CTRL_RW 0x23
struct rt_i2c_priv_data { struct rt_i2c_priv_data
struct rt_i2c_msg *msgs; {
rt_size_t number; 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);
rt_err_t rt_i2c_bus_device_device_init(struct rt_i2c_bus_device* bus,
const char* name);
#ifdef __cplusplus
}
#endif #ifdef __cplusplus
}
#endif #endif
#endif

167
components/drivers/include/rtdevice.h
View File

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