rk3588 i2c algorithm 分析
来了来了，上次分析完i2c的驱动框架 今天我们就看看i2c的algorithm是如何实现的
static const struct i2c_algorithm rk3x_i2c_algorithm = {
.master_xfer = rk3x_i2c_xfer,
.master_xfer_atomic = rk3x_i2c_xfer_polling,
.functionality = rk3x_i2c_func,
};
我们就分析master_xfer 函数怎么实现的把。 .functionality比较简单大家可以自己看看了解一下
直接步入正题把。
1.1 i2c时序
首先给大家说一下发送i2c时序的步骤把
- 发送一个其实信号
- 发送7bit设备地址再加1bit读写.最低为1表示读，0为写
- 主机发送完一个从机地址，假设设备是存在的此时为给设备发送一个ACK应答位
- 发送寄存器地址 8bit数据 如果你的数据是 16bit 那就发两次呗。
- 发送一个8bit 等待ACK，在发送一个就在等一个ACK
- 之后发送数据 最多是32位 所以还是要注意的。发送8bit就等一个ACK 这是必须的
- 下来发送一个停止信号。
1.1.1 起始信号
SCL位高 SDA 来一个下降沿 之后就开始通信把。
1.1.2 数据信号
SCL 为高电平，数据有效。
1.1.3 应答信号
SCL为高 的第9bit 为高 则代表有效 如果ACK没有应答 在驱动中则将停止通信了。
1.1.4 停止信号
SCL为高电平 SDA来个上升沿 就结束了。
这样总结很简单把根据这个我们都可以自己手画了一个时序图了。
好了 有了这些 我们就分析驱动吧。
rk3x_i2c_xfer他调用的式 rk3x_i2c_xfer_common 代码很多我们一句一句看
static int rk3x_i2c_xfer_common(struct i2c_adapter *adap,
struct i2c_msg *msgs, int num, bool polling)
{
struct rk3x_i2c *i2c = (struct rk3x_i2c *)adap->algo_data;
unsigned long timeout, flags;
u32 val;
int ret = 0;
int i;
if (i2c->suspended)
return -EACCES;
spin_lock_irqsave(&i2c->lock, flags); //保存本地中断状态 关闭中断
clk_enable(i2c->clk); //使能了两个时钟
clk_enable(i2c->pclk);
i2c->is_last_msg = false; //把最后一个消息置为否
/*
* Process msgs. We can handle more than one message at once (see
* rk3x_i2c_setup()).
*/
for (i = 0; i < num; i += ret) { //这个num 就是r/w的个数
ret = rk3x_i2c_setup(i2c, msgs + i, num - i); //大概说一下干什么 下面分析 就是判断寄存器地址是否为16bit
if (ret < 0) {
dev_err(i2c->dev, "rk3x_i2c_setup() failed\n");
break;
}
if (i + ret >= num) //判断 当前i+ret(已经传输的个数如果大于) num了 那么就是最后一个信号了 是不是停止信号呢？
i2c->is_last_msg = true;
rk3x_i2c_start(i2c); // 下面分析 大概说一下 就是配置接收发送中断
spin_unlock_irqrestore(&i2c->lock, flags);
if (!polling) { //这个是是否阻塞 如果超时阻塞 那么等待唤醒
timeout = wait_event_timeout(i2c->wait, !i2c->busy,
msecs_to_jiffies(WAIT_TIMEOUT));
} else { //这个暂时不分析了
timeout = rk3x_i2c_wait_xfer_poll(i2c);
}
spin_lock_irqsave(&i2c->lock, flags);
if (timeout == 0) { //返回0了 那就超时了
dev_err(i2c->dev, "timeout, ipd: 0x%02x, state: %d\n",
i2c_readl(i2c, REG_IPD), i2c->state);
/* Force a STOP condition without interrupt */
rk3x_i2c_disable_irq(i2c); //关闭中断
val = i2c_readl(i2c, REG_CON) & REG_CON_TUNING_MASK; //读取 i2c控制器控制寄存器 保存 是否停止配置设置寄存器
val |= REG_CON_EN | REG_CON_STOP; //0x1001 意思是使能i2c模块 并产生一个i2c停止信号
i2c_writel(i2c, val, REG_CON); //写入控制寄存器
i2c->state = STATE_IDLE; //设置为空闲状态
ret = -ETIMEDOUT; //返回超时错误码
break;
}
if (i2c->error) {
ret = i2c->error;
break;
}
}
rk3x_i2c_disable_irq(i2c); //禁用中断
rk3x_i2c_disable(i2c); //除了 保存停止配置设置寄存器的值 剩下都置为0 意思就是把所有都关闭了
clk_disable(i2c->pclk); //关闭时钟
clk_disable(i2c->clk);
spin_unlock_irqrestore(&i2c->lock, flags);
return ret < 0 ? ret : num;
}
看一下 rk3x_i2c_setup
static int rk3x_i2c_setup(struct rk3x_i2c *i2c, struct i2c_msg *msgs, int num)
{
u32 addr = (msgs[0].addr & 0x7f) << 1; //地址左移1bit 这不就和协议对上了 7bit+r/w 位
int ret = 0;
/*
* The I2C adapter can issue a small (len < 4) write packet before
* reading. This speeds up SMBus-style register reads.
* The MRXADDR/MRXRADDR hold the slave address and the slave register
* address in this case.
*/
if (num >= 2 && msgs[0].len < 4 &&
!(msgs[0].flags & I2C_M_RD) && (msgs[1].flags & I2C_M_RD)) { //就是16bit的寄存器
u32 reg_addr = 0;
int i;
dev_dbg(i2c->dev, "Combined write/read from addr 0x%x\n",
addr >> 1);
/* Fill MRXRADDR with the register address(es) */
for (i = 0; i < msgs[0].len; ++i) {
reg_addr |= msgs[0].buf[i] << (i * 8);
reg_addr |= REG_MRXADDR_VALID(i);
} //硬件操作发送16bit寄存器地址
/* msgs[0] is handled by hw. */
i2c->msg = &msgs[1];
i2c->mode = REG_CON_MOD_REGISTER_TX;
i2c_writel(i2c, addr | REG_MRXADDR_VALID(0), REG_MRXADDR); //下来发送数据
i2c_writel(i2c, reg_addr, REG_MRXRADDR);
ret = 2;
} else {
/*
* We'll have to do it the boring way and process the msgs
* one-by-one.
*/
if (msgs[0].flags & I2C_M_RD) {
addr |= 1; /* set read bit */ //设置了一个读位
/*
* We have to transmit the slave addr first. Use
* MOD_REGISTER_TX for that purpose.
*/
i2c->mode = REG_CON_MOD_REGISTER_TX;
i2c_writel(i2c, addr | REG_MRXADDR_VALID(0),
REG_MRXADDR);
i2c_writel(i2c, 0, REG_MRXRADDR);
} else {
i2c->mode = REG_CON_MOD_TX;
}
i2c->msg = &msgs[0];
ret = 1;
}
i2c->addr = msgs[0].addr;
i2c->busy = true;
i2c->processed = 0;
i2c->error = 0;
rk3x_i2c_clean_ipd(i2c);
if (i2c->autostop_supported)
i2c_writel(i2c, 0, REG_CON1);
return ret;
}
看一下 rk3x_i2c_start
static void rk3x_i2c_start(struct rk3x_i2c *i2c)
{
u32 val = i2c_readl(i2c, REG_CON) & REG_CON_TUNING_MASK;
bool auto_stop = rk3x_i2c_auto_stop(i2c);
int length = 0;
/* enable appropriate interrupts */
if (i2c->mode == REG_CON_MOD_TX) {
if (!auto_stop) { //使能发送中断
i2c_writel(i2c, REG_INT_MBTF | REG_INT_NAKRCV, REG_IEN);
i2c->state = STATE_WRITE;
}
length = rk3x_i2c_fill_transmit_buf(i2c, false);
} else {
/* in any other case, we are going to be reading. */
if (!auto_stop) {
i2c_writel(i2c, REG_INT_MBRF | REG_INT_NAKRCV, REG_IEN); //使能接受中断
i2c->state = STATE_READ;
}
}
/* enable adapter with correct mode, send START condition */
val |= REG_CON_EN | REG_CON_MOD(i2c->mode) | REG_CON_START;
/* if we want to react to NACK, set ACTACK bit */
if (!(i2c->msg->flags & I2C_M_IGNORE_NAK))
val |= REG_CON_ACTACK;
i2c_writel(i2c, val, REG_CON);
/* enable transition */
if (i2c->mode == REG_CON_MOD_TX)
i2c_writel(i2c, length, REG_MTXCNT); //使能接受或者发送
else
rk3x_i2c_prepare_read(i2c);
}
差一个irq 明天继续 记录一下思路 开启中断后 每次 将会填充 发送或者接受 数据寄存器 当满了之后呢么保存数据 或者发送 都保存在 msg->buf 里了 这就是所谓了i2c通信算法 就是根据协议去写 更清楚的了解了 i2c协议