imx6ul I2C总线驱动通道2功能不正常

诸葛一帆丶 · 发表于 2017-3-17 16:23:28

本帖最后由诸葛一帆丶于 2017-3-21 10:42 编辑

最近要用到I2C总线，发现以下问题：

使用的IMX6ULEVK 28616

写的I2C总线驱动，测试过能使用I2C通道1正常收发，使用I2C通道2时无法正常通信（整个驱动程序并没有进行修改）。
通过读取寄存器数据发现，在写入从设备地址至I2Cx_I2DR这步中，I2C通道1能正常写入（读取到的值和写入的值相同），I2C通道2无法正常写入（读取到的值为0）。

（寄存器查过地址没问题，都是基址加偏移，1通道基址0x021A0000，2通道基址0x021A4000）

I2C1读取到的寄存器：
I2Cx_I2CR寄存器值为0xb0，
I2Cx_I2SR寄存器值为0xa3，
I2Cx_IFDR寄存器值为0x39，
I2Cx_I2DR寄存器值为0x1a

I2C2读取到的寄存器：
I2Cx_I2CR寄存器值为0xb0，
I2Cx_I2SR寄存器值为0x81，
I2Cx_IFDR寄存器值为0x39，
I2Cx_I2DR寄存器值为0

现在猜测是不是I2C2总线是不是有问题？
或者在驱动程序的哪部分会出现问题呢？
求助

0通道能正常传输，能进中断，1通道无法进中断，（应该是发送从机地址不成功，所以进不了中断）

I2C通道1，从机地址为0x0E，寄存器地址0x07
I2C通道2，从机地址为0x1A，寄存器地址0x00

/*********************************************************************************************************
** 函数名称: __imx6ulI2cStart
** 功能描述: i2c 控制器发送启动字节
** 输　入 : usAddr 地址
** usFlag 标志
** uiChannel 通道号
** 输　出 : NONE
** 全局变量:
** 调用模块:
*********************************************************************************************************/
static VOID __imx6ulI2cStart (UINT16 usAddr,
UINT16 usFlag,
UINT uiChannel)
{
bspDebugMsg(" __imx6ulI2cStart\r\n");
UINT uiValue;
__Gi2cChannel[uiChannel].iStatus = __I2C_BUS_STATE_START; /* 启动总线 */
switch(uiChannel) {
#if 1
case I2C_CHAN_1:
API_InterVectorEnable(IMX_INT_I2C1); /* 启动总线中断 */
break;
case I2C_CHAN_2:
API_InterVectorEnable(IMX_INT_I2C2); /* 启动总线中断 */
break;
case I2C_CHAN_3:
API_InterVectorEnable(IMX_INT_I2C3); /* 启动总线中断 */
break;
case I2C_CHAN_4:
API_InterVectorEnable(IMX_INT_I2C4); /* 启动总线中断 */
break;
#endif
default:
break;
}
uiValue = readw(REG_I2C_I2CR(uiChannel)); /* 使能I2C中断 */
uiValue |= BIT_I2C_I2CR_IIEN;
writew(uiValue, REG_I2C_I2CR(uiChannel));
if (usFlag & LW_I2C_M_RD) { /* 读操作 */
uiValue = readw(REG_I2C_I2CR(uiChannel)); /* 重启总线需要有此操作 */
uiValue |= BIT_I2C_I2CR_RSTA;
writew(uiValue, REG_I2C_I2CR(uiChannel));
writew(((usAddr << 1) | I2C_READ), (REG_I2C_I2DR(uiChannel))); /* 设置器件读地址 */
} else {
uiValue = readw(REG_I2C_I2CR(uiChannel)); /* 主发模式启动 */
uiValue |= (BIT_I2C_I2CR_MSTA | BIT_I2C_I2CR_MTX);
writew(uiValue, REG_I2C_I2CR(uiChannel));
{
writew(((usAddr << 1) | I2C_WRITE), (REG_I2C_I2DR(uiChannel))); /* 设置器件写地址 */
printk("%d pChar = %#x\n", __LINE__, ((usAddr << 1) | I2C_WRITE));
printk("%d uiChannel = %d REG_I2C_I2DR = %#x\n", __LINE__, uiChannel, readw(REG_I2C_I2DR(uiChannel)));
}
}
}
/*********************************************************************************************************
** 函数名称: __imx6ulI2cStop
** 功能描述: i2c 控制器发送停止总线
** 输　入 : uiChannel 通道号
** 输　出 : NONE
** 全局变量:
** 调用模块:
*********************************************************************************************************/
static VOID __imx6ulI2cStop (UINT uiChannel)
{
bspDebugMsg(" __imx6ulI2cStop\r\n");
UINT uiValue;
uiValue = readw(REG_I2C_I2CR(uiChannel)); /* 主收模式停止 */
uiValue &= ~(BIT_I2C_I2CR_MSTA);
writew(uiValue, REG_I2C_I2CR(uiChannel));
__Gi2cChannel[uiChannel].iStatus = __I2C_BUS_STATE_STOP; /* 停止总线 */
API_SemaphoreBPost(__Gi2cChannel[uiChannel].I2C_hSignal); /* 激活等待任务 */
}
/*********************************************************************************************************
** 函数名称:
** 功能描述: i2c 控制器中断处理函数
** 输　入 : pI2cChannel 通道号
** 输　出 : LW_IRQ_HANDLED 系统中断返回值
** 全局变量: NONE
** 调用模块: NONE
********************************************************************************************************/
static irqreturn_t __i2cIsr (UINT uiI2cChannel)
{
bspDebugMsg(" __i2cIsr\r\n");
BYTE ucByte;
ULONG ulStatus;
UINT uiValue;
__PI2C_CHANNEL pI2cChannel = &__Gi2cChannel[uiI2cChannel];
ulStatus = readw(REG_I2C_I2SR(pI2cChannel->uiChannel)); /* i2c 状态 */
ulStatus &= ~BIT_I2C_I2SR_IIF;
writew(ulStatus, REG_I2C_I2SR(pI2cChannel->uiChannel)); /* 清中断 */
uiValue = readw(REG_I2C_I2SR(pI2cChannel->uiChannel));
if ((uiValue & BIT_I2C_I2SR_IAL) > 0) {
/* 中断仲裁 */
errno = ENXIO;
__imx6ulI2cStop(pI2cChannel->uiChannel); /* 停止总线 */
}
switch (pI2cChannel->iStatus) { /* 处理不同状态 */
case __I2C_BUS_STATE_IDLE:
break; /* 直接退出 */
case __I2C_BUS_STATE_START:
if ((__I2C_BUS_IS_LASTMSG(pI2cChannel) && /* 没有待处理的消息 */
(pI2cChannel->pi2cmsg->I2CMSG_usLen == 0))) {
errno = ENXIO;
__imx6ulI2cStop(pI2cChannel->uiChannel); /* 停止总线 */
break;
}
if (pI2cChannel->pi2cmsg->I2CMSG_usFlag & LW_I2C_M_RD) { /* 进入读状态 */
pI2cChannel->iStatus = __I2C_BUS_STATE_READ;
uiValue = readw(REG_I2C_I2CR(pI2cChannel->uiChannel)); /* 主收模式启动 */
uiValue &= ~BIT_I2C_I2CR_MTX;
writew(uiValue, REG_I2C_I2CR(pI2cChannel->uiChannel));
if (pI2cChannel->pi2cmsg->I2CMSG_usLen == 1) { /* 若为最后一个消息，不发送ACK */
uiValue = readw(REG_I2C_I2CR(pI2cChannel->uiChannel));
uiValue |= BIT_I2C_I2CR_TXAK;
writew(uiValue, REG_I2C_I2CR(pI2cChannel->uiChannel));
}
readw(REG_I2C_I2DR(pI2cChannel->uiChannel)); /* dummy read 空读 */
} else {
pI2cChannel->iStatus = __I2C_BUS_STATE_WRITE; /* 进入写状态 */
goto __prepare_write;
}
break;
case __I2C_BUS_STATE_READ:
if (__I2C_BUS_IS_MSGEND(pI2cChannel)) { /* 当前为最后一个字节 */
if (__I2C_BUS_IS_LASTMSG(pI2cChannel)) { /* 这是最后一个消息块 */
pI2cChannel->iMsgPtr = 0;
pI2cChannel->iMsgIndex++; /* 保证与消息数量相同 */
__imx6ulI2cStop(pI2cChannel->uiChannel);
break;
} else {
pI2cChannel->iMsgPtr = 0;
pI2cChannel->iMsgIndex++;
pI2cChannel->pi2cmsg++; /* 开始接收下一个消息 */
}
} else if (__I2C_BUS_IS_MSGLAST(pI2cChannel)) { /* 当前为倒数第二字节 */
if (__I2C_BUS_IS_LASTMSG(pI2cChannel)) { /* 这是最后一个消息块 */
uiValue = readw(REG_I2C_I2CR(pI2cChannel->uiChannel));
uiValue |= BIT_I2C_I2CR_TXAK;
writew(uiValue, REG_I2C_I2CR(pI2cChannel->uiChannel)); /* 下一个字节不发送ACK */
}
}
ucByte = (BYTE)readw(REG_I2C_I2DR(pI2cChannel->uiChannel)); /* 读取数据 */
pI2cChannel->pi2cmsg->I2CMSG_pucBuffer[pI2cChannel->iMsgPtr] = ucByte;
pI2cChannel->iMsgPtr++;
break;
case __I2C_BUS_STATE_WRITE:
if ((ulStatus & BIT_I2C_I2SR_RXAK) && /* 需要 ACK 但没有接收到 ACK */
!(pI2cChannel->pi2cmsg->I2CMSG_usFlag &
LW_I2C_M_IGNORE_NAK)) {
errno = ECONNREFUSED;
__imx6ulI2cStop(pI2cChannel->uiChannel); /* 停止总线 */
break;
}
__prepare_write:
if (!__I2C_BUS_IS_MSGEND(pI2cChannel)) { /* 当前消息还没有发送完 */
ucByte = pI2cChannel->pi2cmsg->I2CMSG_pucBuffer[pI2cChannel->iMsgPtr];
pI2cChannel->iMsgPtr++;
writew((ucByte), (REG_I2C_I2DR(pI2cChannel->uiChannel)));
} else if (!__I2C_BUS_IS_LASTMSG(pI2cChannel)) { /* 还有剩余的消息没有发送完 */
pI2cChannel->iMsgPtr = 0;
pI2cChannel->iMsgIndex++;
pI2cChannel->pi2cmsg++; /* 开始发送下一个消息 */
if (pI2cChannel->pi2cmsg->I2CMSG_usFlag &
LW_I2C_M_NOSTART) { /* 不需要起始位 */
if (pI2cChannel->pi2cmsg->I2CMSG_usFlag &
LW_I2C_M_RD) { /* 读操作 */
/*
* 控制器换向, 必须重启总线
*/
__imx6ulI2cStop(pI2cChannel->uiChannel); /* 不能进行读操作 */
}
goto __prepare_write;
} else {
__imx6ulI2cStart(pI2cChannel->pi2cmsg->I2CMSG_usAddr,
pI2cChannel->pi2cmsg->I2CMSG_usFlag,
pI2cChannel->uiChannel); /* 重启总线 */
}
} else {
pI2cChannel->iMsgPtr = 0;
pI2cChannel->iMsgIndex++; /* 保证与消息数量相同 */
__imx6ulI2cStop(pI2cChannel->uiChannel); /* 发送结束 */
}
break;
case __I2C_BUS_STATE_STOP:
break;
default:
break;
}
return (LW_IRQ_HANDLED);
}
/*********************************************************************************************************
** 函数名称: __i2cTryTransfer
** 功能描述: i2c 尝试传输函数
** 输　入 : uiChannel i2c 通道
** pI2cAdapter i2c 适配器
** pI2cMsg i2c 传输消息组
** iNum 消息数量
** 输　出 : 完成传输的消息数量
** 全局变量:
** 调用模块:
*********************************************************************************************************/
static INT __i2cTryTransfer (UINT uiChannel,
PLW_I2C_ADAPTER pI2cAdapter,
PLW_I2C_MESSAGE pI2cMsg,
INT iNum)
{
bspDebugMsg(" __i2cTryTransfer\r\n");
__Gi2cChannel[uiChannel].iStatus = __I2C_BUS_STATE_START;
__Gi2cChannel[uiChannel].iBpsParam = SPECIFIED_RATE;
__Gi2cChannel[uiChannel].pi2cmsg = pI2cMsg;
__Gi2cChannel[uiChannel].iMsgPtr = 0;
__Gi2cChannel[uiChannel].iMsgNum = iNum;
__Gi2cChannel[uiChannel].iMsgIndex = 0; /* 从第一个开始发送 */
__imx6ulI2cStart(pI2cMsg->I2CMSG_usAddr,
pI2cMsg->I2CMSG_usFlag,
uiChannel); /* 启动总线 */
API_SemaphoreBPend(__Gi2cChannel[uiChannel].I2C_hSignal,
LW_OPTION_WAIT_A_SECOND * 3); /* 最多等待 3 秒钟 */
switch(uiChannel) {
case I2C_CHAN_1:
API_InterVectorDisable(IMX_INT_I2C1); /* 关闭总线中断 */
break;
case I2C_CHAN_2:
API_InterVectorDisable(IMX_INT_I2C2); /* 关闭总线中断 */
break;
case I2C_CHAN_3:
API_InterVectorDisable(IMX_INT_I2C3); /* 关闭总线中断 */
break;
case I2C_CHAN_4:
API_InterVectorDisable(IMX_INT_I2C4); /* 关闭总线中断 */
break;
default:
break;
}
return (__Gi2cChannel[uiChannel].iMsgIndex); /* 返回传输成功的数量 */
}
/*********************************************************************************************************
** 函数名称: __i2cTransfer
** 功能描述: i2c 传输函数
** 输　入 : uiChannel i2c 通道
** pI2cAdapter i2c 适配器
** pI2cMsg i2c 传输消息组
** iNum 消息数量
** 输　出 : ERROR_CODE
** 全局变量:
** 调用模块:
*********************************************************************************************************/
static INT __i2cTransfer (UINT uiChannel,
PLW_I2C_ADAPTER pI2cAdapter,
PLW_I2C_MESSAGE pI2cMsg,
INT iNum)
{
bspDebugMsg(" __i2cTransfer\r\n");
INT i;
for (i = 0; i < pI2cAdapter->I2CADAPTER_iRetry; i++) { /* 错误重传 */
if (__i2cTryTransfer(uiChannel, pI2cAdapter, pI2cMsg, iNum) == iNum) {
return (iNum);
} else {
API_TimeSleep(LW_OPTION_WAIT_A_TICK); /* 等待一个机器周期重试 */
}
}
return (PX_ERROR);
}
/*********************************************************************************************************
** 函数名称: __i2c1Transfer
** 功能描述: i2c1 传输函数
** 输　入 : pI2cAdapter i2c 适配器
** pI2cMsg i2c 传输消息组
** iNum 消息数量
** 输　出 : i2c 传输函数
** 全局变量:
** 调用模块:
*********************************************************************************************************/
static INT __i2c1Transfer (PLW_I2C_ADAPTER pI2cAdapter, /* 抽象成Transfer */
PLW_I2C_MESSAGE pI2cMsg,
INT iNum)
{
return (__i2cTransfer(I2C_CHAN_1,
pI2cAdapter,
pI2cMsg,
iNum));
}
/*********************************************************************************************************
** 函数名称: __i2c2Transfer
** 功能描述: i2c2 传输函数
** 输　入 : pI2cAdapter i2c 适配器
** pI2cMsg i2c 传输消息组
** iNum 消息数量
** 输　出 : i2c 传输函数
** 全局变量:
** 调用模块:
*********************************************************************************************************/
static INT __i2c2Transfer (PLW_I2C_ADAPTER pI2cAdapter, /* 抽象成Transfer */
PLW_I2C_MESSAGE pI2cMsg,
INT iNum)
{
return (__i2cTransfer(I2C_CHAN_2,
pI2cAdapter,
pI2cMsg,
iNum));
}
/*********************************************************************************************************
** 函数名称: __i2c3Transfer
** 功能描述: i2c3 传输函数
** 输　入 : pI2cAdapter i2c 适配器
** pI2cMsg i2c 传输消息组
** iNum 消息数量
** 输　出 : i2c 传输函数
** 全局变量:
** 调用模块:
*********************************************************************************************************/
static INT __i2c3Transfer (PLW_I2C_ADAPTER pI2cAdapter, /* 抽象成Transfer */
PLW_I2C_MESSAGE pI2cMsg,
INT iNum)
{
return (__i2cTransfer(I2C_CHAN_3,
pI2cAdapter,
pI2cMsg,
iNum));
}
/*********************************************************************************************************
** 函数名称: __i2c4Transfer
** 功能描述: i2c4 传输函数
** 输　入 : pI2cAdapter i2c 适配器
** pI2cMsg i2c 传输消息组
** iNum 消息数量
** 输　出 : i2c 传输函数
** 全局变量:
** 调用模块:
*********************************************************************************************************/
static INT __i2c4Transfer (PLW_I2C_ADAPTER pI2cAdapter, /* 抽象成Transfer */
PLW_I2C_MESSAGE pI2cMsg,
INT iNum)
{
return (__i2cTransfer(I2C_CHAN_4,
pI2cAdapter,
pI2cMsg,
iNum));
}
/*********************************************************************************************************
i2c 驱动程序(操作函数集)
*********************************************************************************************************/
static LW_I2C_FUNCS __Gimx6ulI2cFuncs[I2C_CHAN_NUM] = {
{
__i2c1Transfer, /* I2C1传输函数 */
}, {
__i2c2Transfer,
}, {
__i2c3Transfer,
}, {
__i2c4Transfer,
}
};
/*********************************************************************************************************
** 函数名称: __i2cSetI2cClk
** 功能描述: 设置时钟频率
** 输　入 : uiChannel i2c 通道号
** uiBaud 时钟频率参数
** 输　出 : NONE
** 全局变量:
** 调用模块:
*********************************************************************************************************/
static VOID __i2cSetI2cClk (UINT uiChannel, UINT32 uiBaud)
{
/*
* 获取系统时钟
*/
// UINT32 uiSrcClk = ccmMainClkGet(IPG_PER_CLK);
UINT32 uiSrcClk = 75 * 1000 * 1000;
UINT32 uiDivider = uiSrcClk / uiBaud;
UINT8 ucIndex = 0;
UINT uiValue = 0;
/*
* 波特率处理后与数组中对应值匹配，将对应值写入分频寄存器
*/
if (uiDivider < __GusI2cClkDiv[0][0]) {
uiDivider = __GusI2cClkDiv[0][0];
ucIndex = 0;
printk("Warning :can't find a smaller divider than %d.\n",
uiDivider);
printk("SCL frequency is set at %d - expected was %d.\n",
uiSrcClk / uiDivider, uiBaud);
} else if (uiDivider > __GusI2cClkDiv[49][0]) {
uiDivider = __GusI2cClkDiv[49][0];
ucIndex = 49;
printk("Warning: can't find a bigger divider than %d.\n",
uiDivider);
printk("SCL frequency is set at %d - expected was %d.\n",
uiSrcClk / uiDivider, uiBaud);
} else {
for (ucIndex = 0; __GusI2cClkDiv[ucIndex][0] < uiDivider; ucIndex++);
uiDivider = __GusI2cClkDiv[ucIndex][0];
}
/*
* 设置I2C时钟频率
*/
uiValue = readw(REG_I2C_IFDR(uiChannel));
uiValue &= ~BIT_I2C_IFDR_IC_MASK;
uiValue |= __GusI2cClkDiv[ucIndex][1];
writew(uiValue, REG_I2C_IFDR(uiChannel));
}
/*********************************************************************************************************
** 函数名称: __i2cHwInit
** 功能描述: i2c 控制器初始化
** 输　入 : uiChannel i2c 通道
** 输　出 : ERROR_CODE
** 全局变量:
** 调用模块:
*********************************************************************************************************/
static INT __i2cHwInit (UINT uiChannel)
{
UINT uiValue = 0;
__i2cSetI2cClk(uiChannel, I2C_BUS_FREQ_MAX); /* 设置时钟频率 */
/*
* 当作为从设备时，设备地址需自己设置
*/
uiValue = readw(REG_I2C_IADR(uiChannel)); /* 指定从设备地址 */
uiValue &= ~IMXUL_DEFAULT_SLAVE_ID_MASK;
uiValue |= IMXUL_DEFAULT_SLAVE_ID;
writew(uiValue, REG_I2C_IADR(uiChannel));
writew(0, REG_I2C_I2SR(uiChannel)); /* 清零状态寄存器 */
uiValue = readw(REG_I2C_I2CR(uiChannel)); /* 使能I2C */
uiValue |= BIT_I2C_I2CR_IEN;
writew(uiValue, REG_I2C_I2CR(uiChannel));
return (ERROR_NONE);
}
/*********************************************************************************************************
** 函数名称: __i2cInit
** 功能描述: 初始化 i2c 通道
** 输　入 : pI2cChannel i2c 通道
** 输　出 : ERROR_CODE
** 全局变量:
** 调用模块:
*********************************************************************************************************/
static INT __i2cInit (UINT uiChannel)
{
__PI2C_CHANNEL pI2cChannel = &__Gi2cChannel[uiChannel];
if (!pI2cChannel->I2C_bIsInit) { /* 判断通道是否已初始化 */
/*
* 初始化 I2C 使用的信号量
*/
pI2cChannel->I2C_hSignal = API_SemaphoreBCreate("i2c_signal",
LW_FALSE,
LW_OPTION_OBJECT_GLOBAL,
LW_NULL);
if (pI2cChannel->I2C_hSignal == LW_OBJECT_HANDLE_INVALID) {
printk(KERN_ERR "imx6qI2cInit(): failed to create i2c_signal!\n");
goto __error_handle;
}
/*
* 初始化 I2C 控制器
*/
if (__i2cHwInit(pI2cChannel->uiChannel) != ERROR_NONE) {
printk(KERN_ERR "imx6ulI2cInit(): failed to init!\n");
goto __error_handle;
}
switch(pI2cChannel->uiChannel) {
case I2C_CHAN_1:
API_InterVectorConnect(IMX_INT_I2C1,
(PINT_SVR_ROUTINE)__i2cIsr,
(PVOID)uiChannel,
"i2c1_isr");
break;
case I2C_CHAN_2:
API_InterVectorConnect(IMX_INT_I2C2,
(PINT_SVR_ROUTINE)__i2cIsr,
(PVOID)uiChannel,
"i2c2_isr");
break;
case I2C_CHAN_3:
API_InterVectorConnect(IMX_INT_I2C3,
(PINT_SVR_ROUTINE)__i2cIsr,
(PVOID)uiChannel,
"i2c3_isr");
break;
case I2C_CHAN_4:
API_InterVectorConnect(IMX_INT_I2C4,
(PINT_SVR_ROUTINE)__i2cIsr,
(PVOID)uiChannel,
"i2c4_isr");
break;
default:
printk(KERN_ERR "__i2cInit(): I2C channel invalid!\n");
break;
}
pI2cChannel->I2C_bIsInit = LW_TRUE; /* 设置已初始化标志 */
}
return (ERROR_NONE);
__error_handle:
if (pI2cChannel->I2C_hSignal) {
API_SemaphoreBDelete(&pI2cChannel->I2C_hSignal);
pI2cChannel->I2C_hSignal = 0;
}
return (PX_ERROR);
}
/*********************************************************************************************************
** 函数名称: i2cIomuxConfig
** 功能描述: i2c管脚复用
** 输　入 : uiChannel 通道号
** 输　出 : NONE
** 全局变量: NONE
** 调用模块: NONE
********************************************************************************************************/
static VOID __i2cIomuxConfig (UINT uiChannel)
{
switch (uiChannel) {
case I2C_CHAN_1: /* i2c1的管脚复用 */
IomuxConfig(__I2C1_SCL_REG,
__I2C1_SCL_MASK,
__I2C1_SCL_VAL);
IomuxConfig(__I2C1_SDA_REG,
__I2C1_SDA_MASK,
__I2C1_SDA_VAL);
break;
case I2C_CHAN_2: /* i2c2的管脚复用 */
IomuxConfig(__I2C2_SCL_REG,
__I2C2_SCL_MASK,
__I2C2_SCL_VAL);
IomuxConfig(__I2C2_SDA_REG,
__I2C2_SDA_MASK,
__I2C2_SDA_VAL);
break;
case I2C_CHAN_3: /* i2c3的管脚复用 */
IomuxConfig(__I2C3_SCL_REG,
__I2C3_SCL_MASK,
__I2C3_SCL_VAL);
IomuxConfig(__I2C3_SDA_REG,
__I2C3_SDA_MASK,
__I2C3_SDA_VAL);
break;
case I2C_CHAN_4: /* i2c4的管脚复用 */
IomuxConfig(__I2C4_SCL_REG,
__I2C4_SCL_MASK,
__I2C4_SCL_VAL);
IomuxConfig(__I2C4_SDA_REG,
__I2C4_SDA_MASK,
__I2C4_SDA_VAL);
break;
default:
printk(KERN_ERR "i2cBusFuns(): I2C channel invalid!\n");
}
return;
}
/*********************************************************************************************************
** 函数名称: i2cBusFuns
** 功能描述: 初始化 i2c 总线并获取操作函数集
** 输　入 : uiChannel 通道号
** 输　出 : 总线操作函数集
** 全局变量:
** 调用模块:
*********************************************************************************************************/
PLW_I2C_FUNCS i2cBusFuns (UINT uiChannel)
{
/*
* 设置芯片管脚分配，SylixOS 计数从零开始，而 IMX6UL 手册是从 1 开始，需要注意
*/
__i2cIomuxConfig(uiChannel);
if (__i2cInit(uiChannel) != ERROR_NONE) { /* 初始化控制器 */
return (LW_NULL);
}
return (&__Gimx6ulI2cFuncs[uiChannel]); /* 返回操作函数集 */
}
/*********************************************************************************************************
** 函数名称: i2cBusCreate
** 功能描述: 初始化目标电路板i2c总线系统
** 输　入 : NONE
** 输　出 : NONE
** 全局变量:
** 调用模块:
*********************************************************************************************************/
VOID i2cBusCreate (VOID)
{
/*
* 具体配置在common中
*/
PLW_I2C_FUNCS pI2cFuncs;
API_I2cLibInit(); /* 初始化 i2c 组件库 */
#if CONFIG_BSP_I2C0
pI2cFuncs = i2cBusFuns(0); /* 创建 i2c0总线适配器 */
if (pI2cFuncs) {
API_I2cAdapterCreate("/bus/i2c/0", pI2cFuncs, 10, 1); /* 0 对应 I2C0 */
}
#endif
#if CONFIG_BSP_I2C1
pI2cFuncs = i2cBusFuns(1); /* 创建 i2c1总线适配器 */
if (pI2cFuncs) {
API_I2cAdapterCreate("/bus/i2c/1", pI2cFuncs, 10, 1); /* 1 对应 I2C1 */
}
#endif
#if CONFIG_BSP_I2C2
pI2cFuncs = i2cBusFuns(2); /* 创建 i2c2总线适配器 */
if (pI2cFuncs) {
API_I2cAdapterCreate("/bus/i2c/2", pI2cFuncs, 10, 1); /* 2 对应 I2C2 */
}
#endif
#if CONFIG_BSP_I2C3
pI2cFuncs = i2cBusFuns(3); /* 创建 i2c3总线适配器 */
if (pI2cFuncs) {
API_I2cAdapterCreate("/bus/i2c/3", pI2cFuncs, 10, 1); /* 3 对应 I2C3 */
}
#endif
}
/*********************************************************************************************************
** 函数名称: i2cBusDelete
** 功能描述: 卸载目标电路板i2c总线系统
** 输　入 : NONE
** 输　出 : NONE
** 全局变量:
** 调用模块:
*********************************************************************************************************/
VOID i2cBusDelete (VOID)
{
#if CONFIG_BSP_I2C0
API_I2cAdapterDelete("/bus/i2c/0"); /* 0 对应 I2C0 */
#endif
#if CONFIG_BSP_I2C1
API_I2cAdapterDelete("/bus/i2c/1"); /* 1 对应 I2C1 */
#endif
#if CONFIG_BSP_I2C2
API_I2cAdapterDelete("/bus/i2c/2"); /* 2 对应 I2C2 */
#endif
#if CONFIG_BSP_I2C3
API_I2cAdapterDelete("/bus/i2c/3"); /* 3 对应 I2C3 */
#endif
}
/*********************************************************************************************************
** 函数名称: module_init
** 功能描述: module_init()驱动加载模块
** 输　入 : NONE
** 输　出 : NONE
** 全局变量:
** 调用模块:
*********************************************************************************************************/
VOID module_init (VOID)
{
printf("hello_module init!\n");
i2cBusCreate();
UINT8 ucBuf;
UINT8 ucReg = 0x07;
LW_I2C_MESSAGE i2cMsgs[2] = {
{
.I2CMSG_usAddr = 0x0E,
.I2CMSG_usFlag = 0,
.I2CMSG_usLen = 1,
.I2CMSG_pucBuffer = &ucReg,
}, {
.I2CMSG_usAddr = 0x0E,
.I2CMSG_usFlag = LW_I2C_M_RD,
.I2CMSG_usLen = 2,
.I2CMSG_pucBuffer = &ucBuf,
}
};
__i2cTryTransfer(1,LW_NULL,i2cMsgs,2);
printf("%d\n",ucBuf);
}