本文主要描述QNX I2C Drvier的相关内容，并以Texas Instruments DRA71x Jacinto6 Cortex A15处理器为例讲解
I2C 是经常用到的一种总线协议，它只占用两个IO口资源，分别是SCL时钟信号线与SDA数据线，两根线就能将连接与总线上的设备实现数据通信，由于它的简便的构造设计，于是成为一种较为常用的通信方式。在QNX系统里，也提供了I2C驱动框架。
目录结构与组成部分
下面是Texas.Instruments.DRA71x.Jacinto6.Entry.BSP.for.QNX.SDP.6.6包目录，我们只展开跟I2C相关目录内容：
.
├── Makefile
├── images
│ ├── Makefile
│ └── mkflashimage.sh
├── install
├── manifest
├── prebuilt
│ ├── armle-v7
│ │ ├── lib
│ │ │ └── dll
│ │ │ └── devu-omap5-xhci.so
│ │ └── usr
│ │ └── lib
│ │ ├── libfs-flash3.a
│ │ ├── libi2c-master.a
│ │ ├── libio-char.a
│ │ ├── libspi-master.a
│ │ ├── libspi-masterS.a
│ │ └── libutil.a
│ └── usr
│ └── include
│ ├── avb.h
│ ├── cam.h
│ ├── fs
│ ├── hw
│ │ └── i2c.h
│ ├── module.h
│ ├── netdrvr
│ └── xpt.h
├── readme.txt
├── source.xml
└── src
├── Makefile
├── hardware
│ ├── Makefile
│ ├── deva
│ ├── devb
│ ├── devc
│ ├── devi
│ ├── devnp
│ ├── etfs
│ ├── flash
│ ├── i2c
│ │ ├── Makefile
│ │ ├── common.mk
│ │ └── omap35xx
│ │ ├── Makefile
│ │ ├── Usemsg
│ │ ├── Usemsg-omap4
│ │ ├── arm
│ │ ├── bus_recover.c
│ │ ├── bus_speed.c
│ │ ├── clock_toggle.c
│ │ ├── common.mk
│ │ ├── context_restore.c
│ │ ├── context_restore.h
│ │ ├── fini.c
│ │ ├── info.c
│ │ ├── init.c
│ │ ├── lib.c
│ │ ├── module.tmpl
│ │ ├── offsets.h
│ │ ├── options.c
│ │ ├── project.xml
│ │ ├── proto.h
│ │ ├── recv.c
│ │ ├── reg_map_init.c
│ │ ├── reset.c
│ │ ├── send.c
│ │ ├── slave_addr.c
│ │ ├── version.c
│ │ └── wait.c
│ ├── ipl
│ ├── mtouch
│ ├── spi
│ ├── startup
│ └── support
└── utils
├── Makefile
└── r
I2C框架由以下部分组成:
hardware/i2c/* 硬件接口
├── hardware
│ ├── i2c
│ │ ├── Makefile
│ │ ├── common.mk
│ │ └── omap35xx
│ │ ├── Makefile
│ │ ├── Usemsg
│ │ ├── Usemsg-omap4
│ │ ├── arm
│ │ ├── bus_recover.c
│ │ ├── bus_speed.c
│ │ ├── clock_toggle.c
│ │ ├── common.mk
│ │ ├── context_restore.c
│ │ ├── context_restore.h
│ │ ├── fini.c
│ │ ├── info.c
│ │ ├── init.c
│ │ ├── lib.c
│ │ ├── module.tmpl
│ │ ├── offsets.h
│ │ ├── options.c
│ │ ├── project.xml
│ │ ├── proto.h
│ │ ├── recv.c
│ │ ├── reg_map_init.c
│ │ ├── reset.c
│ │ ├── send.c
│ │ ├── slave_addr.c
│ │ ├── version.c
│ │ └── wait.c
lib/i2c 资源管理器层
├── prebuilt
│ ├── armle-v7
│ │ ├── lib
│ │ │ └── dll
│ │ │ └── devu-omap5-xhci.so
│ │ └── usr
│ │ └── lib
│ │ ├── libfs-flash3.a
│ │ ├── libi2c-master.a
│ │ ├── libio-char.a
│ │ ├── libspi-master.a
│ │ ├── libspi-masterS.a
│ │ └── libutil.a
<hw/i2c.h> 定义硬件和应用程序接口的公共头文件
├── prebuilt
│ ├── armle-v7
│ │ ├── lib
│ │ │ └── dll
│ │ └── usr
│ │ └── lib
│ └── usr
│ └── include
│ ├── hw
│ │ └── i2c.h
2C总线最常见的应用是对从设备寄存器的低带宽、低速率访问，例如:编写音频编解码器、编程一个RTC程序、读取温度传感器数据等等。 通常，总线上只交换几个字节。可以将I2C主机实现为单线程资源管理器或专用应用程序。资源管理器接口的主要优点是:
1、它为应用程序开发人员提供了一个清晰、易于理解的思路。
2、它作为一个中介，在多个应用程序对一个或多个从设备之间进行访问，强制不同I2C接口之间的一致性。
3、对于专用的i2c总线应用程序，硬件访问库更有效；硬件接口定义了这个库的接口，有助于维护和代码可移植性。
QNX I2C驱动提供了基本的硬件操作接口，其接口名称为i2c_master_funcs_t，这些接口是驱动里要求实现，包括读写、设置地址、总线速度、版本信息等等。每个接口对应于上面的一个文件.c，这样便于模块化。
硬件管理接口
typedef struct {
size_t size; /* size of this structure */
int (*version_info)(i2c_libversion_t *version);
void *(*init)(int argc, char *argv[]);
void (*fini)(void *hdl);
i2c_status_t (*send)(void *hdl, void *buf, unsigned int len,
unsigned int stop);
i2c_status_t (*recv)(void *hdl, void *buf, unsigned int len,
unsigned int stop);
int (*abort)(void *hdl, int rcvid);
int (*set_slave_addr)(void *hdl, unsigned int addr, i2c_addrfmt_t fmt);
int (*set_bus_speed)(void *hdl, unsigned int speed, unsigned int *ospeed);
int (*driver_info)(void *hdl, i2c_driver_info_t *info);
int (*ctl)(void *hdl, int cmd, void *msg, int msglen,
int *nbytes, int *info);
int (*bus_reset)(void *hdl);
} i2c_master_funcs_t;
在hardware/i2c/目录中，能找到对应函数的实现。
├── i2c
│ ├── Makefile
│ ├── common.mk
│ └── omap35xx
│ ├── Makefile
│ ├── Usemsg
│ ├── Usemsg-omap4
│ ├── arm
│ ├── bus_recover.c
│ ├── bus_speed.c # int (*set_bus_speed)(void *hdl, unsigned int speed, unsigned int *ospeed);
│ ├── clock_toggle.c
│ ├── common.mk
│ ├── context_restore.c
│ ├── context_restore.h
│ ├── fini.c # void (*fini)(void *hdl);
│ ├── info.c # int (*driver_info)(void *hdl, i2c_driver_info_t *info);
│ ├── init.c # void *(*init)(int argc, char *argv[]);
│ ├── lib.c
│ ├── module.tmpl
│ ├── offsets.h
│ ├── options.c
│ ├── project.xml
│ ├── proto.h
│ ├── recv.c # i2c_status_t (*recv)(void *hdl, void *buf, unsigned int len, unsigned int stop);
│ ├── reg_map_init.c
│ ├── reset.c # int (*bus_reset)(void *hdl);
│ ├── send.c # i2c_status_t (*send)(void *hdl, void *buf, unsigned int len, unsigned int stop);
│ ├── slave_addr.c # int (*set_slave_addr)(void *hdl, unsigned int addr, i2c_addrfmt_t fmt);
│ ├── version.c # int (*version_info)(i2c_libversion_t *version);
│ └── wait.c
硬件访问接口
这是整个硬件接口函数，提供了10个接口函数，分别对10个接口函数进行介绍：
version_info函数
version_info函数来获取关于库版本的信息。这个函数的原型是：
int (*version_info)(i2c_libversion_t *version);
version参数是指向这个函数必须填充的i2c_libversion_t结构的指针。该结构定义如下:
typedef struct {
unsigned char major;
unsigned char minor;
unsigned char revision;
} i2c_libversion_t;
具体驱动实现：
int omap_version_info(i2c_libversion_t *version)
{
version->major = I2CLIB_VERSION_MAJOR;
version->minor = I2CLIB_VERSION_MINOR;
version->revision = I2CLIB_REVISION;
return 0;
}
init函数
init函数初始化主接口。该函数的原型是:
void *(*init)(int argc, char *argv[]);
参数是在命令行上传递的。函数返回传递给所有其他函数的句柄，如果发生错误则返回NULL。这个函数主要根据命令行解析来进行I2C初始化。
具体驱动实现：
void *omap_init(int argc, char *argv[])
{
omap_dev_t *dev;
uint16_t s;
if (-1 == ThreadCtl(_NTO_TCTL_IO, 0)) {
perror("ThreadCtl");
return NULL;
}
dev = malloc(sizeof(omap_dev_t));
if (!dev)
return NULL;
dev->speed = 100000;
//根据命令 配置I2C相关参数包括基地址 中断号
if (-1 == omap_options(dev, argc, argv)) {
fprintf(stderr, "omap_options: parse I2C option failed\n");
goto fail_free_dev;
}
//I2C 物理地址映射
dev->regbase = mmap_device_io(dev->reglen, dev->physbase);
if (dev->regbase == (uintptr_t)MAP_FAILED) {
perror("mmap_device_io");
goto fail_free_dev;
}
/* Initialize interrupt handler */
if ((dev->chid = ChannelCreate(_NTO_CHF_DISCONNECT | _NTO_CHF_UNBLOCK)) == -1) {
perror("ChannelCreate");
goto fail_unmap_io;
}
if ((dev->coid = ConnectAttach(0, 0, dev->chid, _NTO_SIDE_CHANNEL, 0)) == -1) {
perror("ConnectAttach");
goto fail_chnl_dstr;
}
dev->intrevent.sigev_notify = SIGEV_PULSE;
dev->intrevent.sigev_coid = dev->coid;
dev->intrevent.sigev_code = OMAP_I2C_EVENT;
dev->intrevent.sigev_priority = dev->intr_priority;
/*
* Attach interrupt
*/
dev->iid = InterruptAttach(dev->intr, i2c_intr, dev, 0, _NTO_INTR_FLAGS_TRK_MSK);
if (dev->iid == -1) {
perror("InterruptAttachEvent");
goto fail_con_dtch;
}
if (omap_reg_map_init(dev) == -1) {
goto fail_intr_dtch;
}
if (context_restore_init(dev) == -1) {
goto fail_ctxt_rest;
}
if (omap_clock_toggle_init(dev) == -1) {
goto fail_ctxt_rest;
}
// I2C 系统时钟初始化
/* Set up the fifo size - Get total size */
omap_clock_enable(dev);
s = (in16(dev->regbase + OMAP_I2C_BUFSTAT) >> 14) & 0x3;
omap_clock_disable(dev);
dev->fifo_size = 0x8 << s;
/* Set up notification threshold as half the total available size. */
dev->fifo_size >>=1;
if (omap_i2c_reset(dev) == -1) {
fprintf(stderr, "omap_i2c_reset: reset I2C interface failed\n");
goto fail_ctxt_rest;
}
return dev;
//失败退出处理
fail_ctxt_rest:
context_restore_fini(dev);
fail_intr_dtch:
InterruptDetach(dev->iid);
fail_con_dtch:
ConnectDetach(dev->coid);
fail_chnl_dstr:
ChannelDestroy(dev->chid);
fail_unmap_io:
munmap_device_io(dev->regbase, dev->reglen);
fail_free_dev:
free(dev);
return NULL;
}
fini函数
fini函数清理驱动程序并释放与给定句柄关联的所有内存。该函数的原型是:
void (*fini)(void *hdl);
具体源码实现：
void omap_fini(void *hdl)
{
omap_dev_t *dev = hdl;
omap_clock_enable(dev);
out16(dev->regbase + OMAP_I2C_CON, 0);
out16(dev->regbase + OMAP_I2C_IE, 0);
omap_clock_disable(dev);
InterruptDetach(dev->iid); // 释放中断映射
ConnectDetach(dev->coid); // 断开消息传递(Message-passing)Channel连接
ChannelDestroy(dev->chid); // 释放消息传递(Message-passing)Channel
// 时钟控制物理地址映射释放
if (dev->clkctrl_base) {
munmap_device_io (dev->clkctrl_base, 4);
}
if (dev->clkstctrl_base) {
munmap_device_io (dev->clkstctrl_base, 4);
}
context_restore_fini(dev);
// 整个I2C控制器物理地址映射释放
munmap_device_io (dev->regbase, dev->reglen);
free (hdl);
}
send函数
发送函数启动主发送。通信完成时将发送一个可选事件(可以释放数据缓冲区)。如果此函数失败，则未启动任何通信。
该函数的原型是:
i2c_status_t (*send)(void *hdl, void *buf, unsigned int len, unsigned int stop);
/*
* Master send.
* Parameters:
* (in) hdl Handle returned from init() init函数返回的句柄；
* (in) buf Buffer of data to send 指向要发送的数据缓冲区的指针；
* (in) len Length in bytes of buf 要发送的数据的长度(以字节为单位)；
* (in) stop If !0, set stop condition when send completes 要发送的数据的长度(以字节为单位)；
* Returns:
* bitmask of status bits
返回状态为：
I2C_STATUS_DONE：传输完成，并且没有错误。
I2C_STATUS_ERROR：传输错误
I2C_STATUS_NACK：没有ACK
I2C_STATUS_ARBL：失去了仲裁。
I2C_STATUS_BUSY：传输超时
I2C_STATUS_ABORT：传输终止
*/
具体源码实现：
i2c_status_t omap_send(void *hdl, void *buf, unsigned int len, unsigned int stop)
{
omap_dev_t *dev = hdl;
i2c_status_t ret = I2C_STATUS_ERROR;
int num_bytes;
if (len <= 0)
return I2C_STATUS_DONE;
if (-1 == omap_wait_bus_not_busy(dev, stop))
return I2C_STATUS_BUSY;
omap_clock_enable(dev);
dev->xlen = len;
dev->buf = buf;
dev->status = 0;
dev->intexpected = 1;
/* set slave address */
if (dev->slave_addr_fmt == I2C_ADDRFMT_7BIT)
out16(dev->regbase + OMAP_I2C_CON, in16(dev->regbase + OMAP_I2C_CON) & (~OMAP_I2C_CON_XSA));
else
out16(dev->regbase + OMAP_I2C_CON, in16(dev->regbase + OMAP_I2C_CON) | OMAP_I2C_CON_XSA);
out16(dev->regbase + OMAP_I2C_SA, dev->slave_addr);
/* set data count */
out16(dev->regbase + OMAP_I2C_CNT, len);
/* Clear the FIFO Buffers */
out16(dev->regbase + OMAP_I2C_BUF, in16(dev->regbase + OMAP_I2C_BUF)| OMAP_I2C_BUF_RXFIF_CLR | OMAP_I2C_BUF_TXFIF_CLR);
/* pre-fill the fifo with outgoing data */
if (dev->xlen > dev->fifo_size)
num_bytes = dev->fifo_size;
else
num_bytes = dev->xlen;
while (num_bytes)
{
out8(dev->regbase + OMAP_I2C_DATA, *dev->buf++);
dev->xlen--;
num_bytes--;
}
/* set start condition */
out16(dev->regbase + OMAP_I2C_CON,
OMAP_I2C_CON_EN |
OMAP_I2C_CON_MST |
OMAP_I2C_CON_TRX |
OMAP_I2C_CON_STT |
(stop? OMAP_I2C_CON_STP : 0)|
(in16(dev->regbase + OMAP_I2C_CON)&OMAP_I2C_CON_XA));
ret= omap_wait_status(dev);
omap_clock_disable(dev);
return ret;
}
recv函数
recv函数启动主接收。传输完成时将发送一个可选事件(可以使用数据缓冲区)。如果此函数失败，则未启动任何传输。
该函数的原型是:
i2c_status_t (*recv)(void *hdl, void *buf, unsigned int len, unsigned int stop);
/*
* Master receive.
* Parameters:
* (in) hdl Handle returned from init() init函数返回的句柄；
* (in) buf Buffer for received data 指向要接收的数据缓冲区的指针；
* (in) len Length in bytes of buf 要接收的数据的长度(以字节为单位)；
* (in) stop If !0, set stop condition when recv completes 如果这是非零的，函数将在发送完成时设置停止条件；
* Returns:
* bitmask of status bits
返回状态为：
I2C_STATUS_DONE：传输完成，并且没有错误。
I2C_STATUS_ERROR：传输错误
I2C_STATUS_NACK：没有ACK
I2C_STATUS_ARBL：失去了仲裁。
I2C_STATUS_BUSY：传输超时
I2C_STATUS_ABORT：传输终止
*/
具体源码实现：
i2c_status_t omap_recv(void *hdl, void *buf, unsigned int len, unsigned int stop)
{
omap_dev_t *dev = hdl;
i2c_status_t ret;
if (len <= 0)
return I2C_STATUS_DONE;
if (-1 == omap_wait_bus_not_busy(dev, stop))
return I2C_STATUS_BUSY;
dev->xlen = len;
dev->buf = buf;
dev->status = 0;
dev->intexpected = 1;
omap_clock_enable(dev);
/* set slave address */
if (dev->slave_addr_fmt == I2C_ADDRFMT_7BIT)
out16(dev->regbase + OMAP_I2C_CON, in16(dev->regbase + OMAP_I2C_CON) & (~OMAP_I2C_CON_XSA));
else
out16(dev->regbase + OMAP_I2C_CON, in16(dev->regbase + OMAP_I2C_CON) | OMAP_I2C_CON_XSA);
out16(dev->regbase + OMAP_I2C_SA, dev->slave_addr);
/* set data count */
out16(dev->regbase + OMAP_I2C_CNT, len);
/* Clear the FIFO Buffers */
out16(dev->regbase + OMAP_I2C_BUF, in16(dev->regbase + OMAP_I2C_BUF)| OMAP_I2C_BUF_RXFIF_CLR | OMAP_I2C_BUF_TXFIF_CLR);
/* set start condition */
out16(dev->regbase + OMAP_I2C_CON,
OMAP_I2C_CON_EN |
OMAP_I2C_CON_MST |
OMAP_I2C_CON_STT |
(stop? OMAP_I2C_CON_STP : 0) |
(in16(dev->regbase + OMAP_I2C_CON)&OMAP_I2C_CON_XA));
ret= omap_wait_status(dev);
omap_clock_disable(dev);
return ret;
}
abort函数
中止功能迫使主程序释放总线。当停止条件被发送时，它返回。
该函数的原型是:
int (*abort)(void *hdl, int rcvid);
/*
* Force the master to free the bus.
* Returns when the stop condition has been sent.
* Returns:
* 0 success
* -1 failure
*/
此处I2C驱动不需要进行abort操作。所以abort函数在resmgr层注册的时候为NULL。
set_slave_addr函数
set_slave_addr函数指定目标从地址。该函数的原型是:
int (*set_slave_addr)(void *hdl, unsigned int addr, i2c_addrfmt_t fmt);
/*
hdl: init函数返回的句柄。
addr: 目标从地址。
fmt:地址的格式; I2C_ADDRFMT_7BIT 和I2C_ADDRFMT_10BIT
*/
具体源码实现：
int omap_set_slave_addr(void *hdl, unsigned int addr, i2c_addrfmt_t fmt)
{
omap_dev_t *dev = hdl;
if(fmt != I2C_ADDRFMT_7BIT && fmt != I2C_ADDRFMT_10BIT)
return -1;
dev->slave_addr = addr;
dev->slave_addr_fmt = fmt;
return 0;
}
set_bus_speed函数
set_bus_speed函数指定总线速度。如果请求的总线速度无效，该函数将返回一个失败，并保持总线速度不变。
该函数的原型是:
int (*set_bus_speed)(void *hdl, unsigned int speed, unsigned int *ospeed);
/*
* Specify the bus speed.
* If an invalid bus speed is requested, this function should return
* failure and leave the bus speed unchanged.
* Parameters:
* (in) hdl Handle returned from init() init函数返回的句柄；
* (in) speed Bus speed. Units are implementation-defined. 总线的速度。
* (out) ospeed Actual bus speed (if NULL, this is ignored) NULL或指向函数应该存储实际总线速度的位置的指针。
* Returns:
* 0 success
* -1 failure
*/
具体源码实现：
int
omap_set_bus_speed(void *hdl, unsigned int speed, unsigned int *ospeed)
{
omap_dev_t *dev = hdl;
unsigned long iclk;
unsigned scll_plus_sclh;
int scll_delta;
int high_adjust;
int low_adjust;
int scll_to_write;
int sclh_to_write;
/* This driver support bus speed range from 8KHz to 400KHz
* limit the low bus speed to 8KHz to protect SCLL/SCLH from overflow(large than 0xff)
* if speed=8KHz, iclk=4MHz, then SCLL=0xf3, SCLH=0xf5
*/
if (speed > 400000 || speed < 8000) {
fprintf(stderr, "i2c-omap35xx: Invalid bus speed(%d)\n", speed);
errno = EINVAL;
return -1;
}
omap_clock_enable(dev);
/* Set the I2C prescaler register to obtain the maximum I2C bit rates
* and the maximum period of the filtered spikes in F/S mode:
* Stander Mode: I2Ci_INTERNAL_CLK = 4 MHz
* Fast Mode: I2Ci_INTERNAL_CLK = 9.6 MHz
*/
if (speed <= 100000) {
#ifdef VARIANT_j5
out16(dev->regbase + OMAP_I2C_PSC, 11); // The sysclk is 48 MHz in J5 and 96 MHz in OMAP
#else
out16(dev->regbase + OMAP_I2C_PSC, 23); // I2Ci_INTERNAL_CLK = 4 MHz
#endif
iclk = OMAP_I2C_ICLK;
high_adjust = dev->high_adjust_slow;
low_adjust = dev->low_adjust_slow;
// in standard mode, scll is smaller than (scll_plus_sclh>>1) by 1
scll_delta = -1;
} else {
#ifdef VARIANT_j5
out16(dev->regbase + OMAP_I2C_PSC, 4); // The sysclk is 48 MHz in J5 and 96 MHz in OMAP
#else
out16(dev->regbase + OMAP_I2C_PSC, 9); // I2Ci_INTERNAL_CLK = 9.6 MHz
#endif
iclk = OMAP_I2C_ICLK_9600K;
high_adjust = dev->high_adjust_fast;
low_adjust = dev->low_adjust_fast;
#ifdef VARIANT_omap4
// in fast mode, scll is larger than (scll_plus_sclh>>1) by 1
scll_delta = 1;
#else
// At this point it is unclear whether omap3 also has this relationship
// between SCLL and SCLH in fast mode, so we leave it alone for now to
// avoid breakage.
scll_delta = -1;
#endif
}
/* Set clock based on "speed" bps */
scll_plus_sclh = (iclk/speed - (SCLL_BIAS + SCLH_BIAS));
scll_to_write = (scll_plus_sclh>>1) + scll_delta;
sclh_to_write = scll_plus_sclh - scll_to_write;
scll_to_write += low_adjust;
sclh_to_write += high_adjust;
if (scll_to_write < 0) scll_to_write = 0;
if (sclh_to_write <= 2) sclh_to_write = 3;
out16(dev->regbase + OMAP_I2C_SCLL, scll_to_write);
out16(dev->regbase + OMAP_I2C_SCLH, sclh_to_write);
dev->speed = iclk / (scll_to_write + SCLL_BIAS + sclh_to_write + SCLH_BIAS);
if (ospeed)
*ospeed = dev->speed;
omap_clock_disable(dev);
return 0;
}
driver_info函数
driver_info函数返回有关驱动程序的信息。该函数的原型是:
int (*driver_info)(void *hdl, i2c_driver_info_t *info);
/*
hdl init函数返回的句柄
info
一个指向i2c_driver_info_t结构的指针，函数应该在该结构中存储信息:
typedef struct {
uint32_t speed_mode;
uint32_t addr_mode;
uint32_t reserved[2];
} i2c_driver_info_t;
*/
具体源码实现：
int omap_driver_info(void *hdl, i2c_driver_info_t *info)
{
info->speed_mode = I2C_SPEED_STANDARD | I2C_SPEED_FAST;
info->addr_mode = I2C_ADDRFMT_7BIT | I2C_ADDRFMT_10BIT;
return 0;
}
ctl函数
ctl函数处理一个驱动程序特定的devctl()命令。该函数的原型是:
int (*ctl)(void *hdl, int cmd, void *msg, int msglen, int *nbytes, int *info);
/*
* Handle a driver-specific devctl().
* Parameters:
* (in) hdl Handle returned from init() init函数返回的句柄；
* (in) cmd Device command 设备命令；
* (i/o) msg Message buffer 一个指向消息缓冲区的指针。该函数可以更改缓冲区的内容；
* (in) msglen Length of message buffer in bytes 消息缓冲区的长度，以字节为单位；
* (out) nbytes Bytes to return (<= msglen) 消息缓冲区的长度，以字节为单位；
* (out) info Extra status information returned by devctl 指向函数可以存储devctl()返回状态信息的位置指针；
* Returns:
* EOK success
* errno failure
*/
此处I2C驱动不需要进行devctrl操作。所以ctl函数在resmgr层注册的时候为NULL。
共享库的接口
当I2C主设备专用于单个应用程序使用时，可以将硬件接口代码编译为库并将其链接到应用程序。
为了提高代码的可移植性，应用程序应该调用i2c_master_getfuncs()来访问特定于硬件的函数。通过功能表访问硬件库，应用程序更容易加载和管理多个硬件库。
资源管理器接口以类似的方式使用硬件库。
资源管理器设计
资源管理器层实现为静态链接到硬件库的库，提供了一个单线程管理器，libi2c-master。
在启动时，resmgr层执行以下操作：
i2c_master_getfuncs(&masterf) masterf.init() masterf.set_bus_speed() 然后，资源管理器让自己在后台运行，下面是资源管理器处理这些devctl()命令:
DCMD_I2C_DRIVER_INFO calls masterf.driver_info(). DCMD_I2C_SET_BUS_SPEED and DCMD_I2C_SET_SLAVE_ADDR only update the state of the current connection. DCMD_I2C_SEND, DCMD_I2C_RECV, DCMD_I2C_SENDRECV, DCMD_I2C_MASTER_SEND, and DCMD_I2C_MASTER_RECV
if (bus_speed has changed)
masterf.set_bus_speed()
masterf.set_slave_address()
masterf.send() or masterf.recv()
资源管理器线程一直占用，直到传输完成并回复客户端，可以通过向资源管理器发送SIGTERM来终止它。
实质和下面流程一样。在初始化里设置一个中断事件，这个事件将发送消息告诉主循环接收和发送数据。
#include <hw/i2c.h>
i2c_master_funcs_t masterf;
i2c_libversion_t version;
i2c_status_t status; void *hdl;
i2c_master_getfuncs(&masterf, sizeof(masterf));//初始化硬件接口 masterf.version_info(&version);
if ((version.major != I2CLIB_VERSION_MAJOR) || (version.minor > I2CLIB_VERSION_MINOR))
{
/* error */
...
}
hdl = masterf.init(...); //调用初始化函数
masterf.set_bus_speed(hdl, ...); //设置总线速度
while(1)
{
InterruptWait (NULL, NULL);
masterf.set_slave_addr(hdl, ...); //设置从地址
status = masterf.send(hdl, ...);//发送数据
if (status != I2C_STATUS_DONE) { /* error */
if (!(status & I2C_STATUS_DONE))
masterf.abort(hdl); }
status = masterf.recv(hdl, ...);//接收数据
if (status != I2C_STATUS_DONE)
{ /* error */ ... }
}
masterf.fini(hdl);//完成I2C传输后，清理驱动程序并释放与给定句柄关联的所有内存
InterruptUnmask(INTNUM, id);
}
masterf.fini(hdl);//完成I2C传输后，清理驱动程序并释放与给定句柄关联的所有内存
参考文献：
Technical Notes I2C (Inter-Integrated Circuit) Framework(qnx.com)
892
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
