ov2640子设备核心操作详细分析

ov2640子设备核心操作详细分析

---

---

ov2640_subdev_core_ops核心操作

// ov2640子设备核心操作
static struct v4l2_subdev_core_ops ov2640_subdev_core_ops = {
#ifdef CONFIG_VIDEO_ADV_DEBUG
    .g_register    = ov2640_g_register, // 获取寄存器值
    .s_register    = ov2640_s_register, // 设置寄存器值
#endif
    .s_power    = ov2640_s_power, // 设置ov2640的电源
};

获取寄存器值ov2640_g_register

函数名为ov2640_g_register，接受一个v4l2_subdev结构体指针和一个v4l2_dbg_register结构体指针reg作为参数。
函数的主要功能如下：
从v4l2_subdev结构体中获取i2c_client结构体指针，该结构体用于表示I2C设备。
设置要读取的寄存器的大小为1字节，并检查要读取的寄存器地址是否有效，如果无效则返回-EINVAL表示无效参数。
使用i2c_smbus_read_byte_data函数通过I2C总线读取指定寄存器的值。
如果读取成功，将读取的值赋给reg->val字段，并返回0表示成功。
如果读取失败，直接返回读取函数的返回值。
该函数的作用是通过使用I2C总线读取指定寄存器的值，并将读取的值存储在reg->val字段中，以实现获取寄存器值的功能。

// 获取指定寄存器的值
static int ov2640_g_register(struct v4l2_subdev *sd,
                 struct v4l2_dbg_register *reg)
{
    // 获取i2c_client结构体
    struct i2c_client *client = v4l2_get_subdevdata(sd);
    // 定义变量
    int ret;

    reg->size = 1;
    if (reg->reg > 0xff)
        return -EINVAL;

    // 通过I2C总线读取指定寄存器的值
    ret = i2c_smbus_read_byte_data(client, reg->reg);
    if (ret < 0)
        return ret;

    reg->val = ret;

    return 0;
}

函数名为 i2c_smbus_read_byte_data，接受一个 i2c_client 结构体指针 client 和一个 u8 类型的命令 command 作为参数。
函数的主要功能如下：
定义一个联合体变量 data，用于存储读取的数据。
定义一个整型变量 status，用于存储函数执行的状态。
调用 i2c_smbus_xfer 函数，传入适配器、地址、标志位，以及读取操作的参数，包括命令 command 和数据类型为字节型。
执行读取操作，并将读取的数据存储在 data 中。
返回执行结果，如果 status 小于 0，返回 status，否则返回 data.byte。
该函数的作用是通过使用 I2C 总线进行读取操作，读取指定地址的寄存器的字节数据，并返回读取的结果。

s32 i2c_smbus_read_byte_data(const struct i2c_client *client, u8 command)
{
    union i2c_smbus_data data; // 定义一个联合体变量data
    int status; // 定义一个整型变量status

    status = i2c_smbus_xfer(client->adapter, client->addr, client->flags, // 调用i2c_smbus_xfer函数，传入适配器、地址、标志位
                I2C_SMBUS_READ, command, // 读取操作，命令为command
                I2C_SMBUS_BYTE_DATA, &data); // 读取一个字节的数据，存储在data中

    return (status < 0) ? status : data.byte; // 如果status小于0，返回status，否则返回data.byte
}

设置寄存器值ov2640_s_register

这段代码用于设置指定寄存器的值。
函数名为ov2640_s_register，接受一个v4l2_subdev结构体指针和一个v4l2_dbg_register结构体指针reg作为参数。
函数的主要功能如下：
从v4l2_subdev结构体中获取i2c_client结构体指针，该结构体用于表示I2C设备。
检查要设置的寄存器地址和值是否超出有效范围，如果超出范围，则返回-EINVAL表示无效参数。
使用i2c_smbus_write_byte_data函数通过I2C总线向指定寄存器写入指定的值。
返回i2c_smbus_write_byte_data函数的返回值。
该函数的作用是通过使用I2C总线向指定的寄存器写入指定的值，以实现设置寄存器的功能。

// 设置指定寄存器的值
static int ov2640_s_register(struct v4l2_subdev *sd,
                 const struct v4l2_dbg_register *reg)
{
    // 获取i2c_client结构体
    struct i2c_client *client = v4l2_get_subdevdata(sd);

    if (reg->reg > 0xff ||
        reg->val > 0xff)
        return -EINVAL;

    // 通过I2C总线向指定寄存器写入指定值
    return i2c_smbus_write_byte_data(client, reg->reg, reg->val);
}

/driver/i2c/i2c-core.c
函数名为 i2c_smbus_write_byte_data，接受一个 i2c_client 结构体指针 client、一个 u8 类型的命令 command，以及一个 u8 类型的值 value 作为参数。
函数的主要功能如下：
定义一个联合体变量 data，用于存储要写入的数据。
将参数 value 的值存储在 data 中。
调用 i2c_smbus_xfer 函数，传入适配器、地址、标志位，以及写入操作的参数，包括命令 command 和数据类型为字节型，以及存储要写入数据的地址 &data。
执行写入操作，并将结果返回。
该函数的作用是通过使用 I2C 总线进行写入操作，将指定地址的寄存器写入一个字节的数据，返回写入操作的结果。
s32 i2c_smbus_write_byte_data(const struct i2c_client *client, u8 command, u8 value)
{
union i2c_smbus_data data; // 定义一个联合体变量data
data.byte = value; // 将value存储在data中
return i2c_smbus_xfer(client->adapter, client->addr, client->flags, // 调用i2c_smbus_xfer函数，传入适配器、地址、标志位
I2C_SMBUS_WRITE, command, // 写入操作，命令为command
I2C_SMBUS_BYTE_DATA, &data); // 写入一个字节的数据，存储在data中
}

i2c_smbus_xfer

Linux内核驱动程序：使用模拟I2C

Linux-4.9.88\drivers\i2c\busses\i2c-gpio.c
Linux-5.4\drivers\i2c\busses\i2c-gpio.c
Linux内核真正的I2C控制器驱动程序
IMX6ULL: Linux-4.9.88\drivers\i2c\busses\i2c-imx.c

ov2640_s_register->i2c_smbus_write_byte_data->i2c_smbus_xfer
函数名为 i2c_smbus_xfer，接受一个 i2c_adapter 结构体指针 adapter、一个 u16 类型的地址 addr、一个 unsigned short 类型的标志位 flags、一个 char 类型的读写操作 read_write、一个 u8 类型的命令 command、一个 int 类型的协议 protocol，以及一个 union i2c_smbus_data 联合体指针 data 作为参数。
函数的主要功能如下：
执行跟踪点追踪，记录有关 SMBus 写入和读取操作的信息。
对标志位进行处理，只保留 I2C_M_TEN、I2C_CLIENT_PEC 和 I2C_CLIENT_SCCB 三个标志位。
如果适配器的算法中实现了 smbus_xfer 函数，则使用该函数进行 SMBus 传输。在仲裁丢失的情况下自动重试，直到达到最大重试次数或超时。
如果适配器的算法没有实现 smbus_xfer 函数或返回 -EOPNOTSUPP，则回退到使用 i2c_smbus_xfer_emulated 函数进行传输。
执行跟踪点追踪，记录有关 SMBus 回复和结果的信息。
返回传输的结果。
该函数的作用是通过使用 I2C 总线进行 SMBus 传输。它根据适配器的支持情况选择合适的传输方法，并处理重试和回退逻辑，最终返回传输的结果。

s32 i2c_smbus_xfer(struct i2c_adapter *adapter, u16 addr, unsigned short flags,
           char read_write, u8 command, int protocol,
           union i2c_smbus_data *data)
{
    unsigned long orig_jiffies;
    int try;
    s32 res;

    /* 如果启用，则以下两个跟踪点取决于读写和协议。*/
    trace_smbus_write(adapter, addr, flags, read_write,
              command, protocol, data);
    trace_smbus_read(adapter, addr, flags, read_write,
             command, protocol);

    /* 仅保留I2C_M_TEN、I2C_CLIENT_PEC和I2C_CLIENT_SCCB标志 */
    flags &= I2C_M_TEN | I2C_CLIENT_PEC | I2C_CLIENT_SCCB;

    if (adapter->algo->smbus_xfer) {
        i2c_lock_adapter(adapter);

        /* 在仲裁丢失的情况下自动重试 */
        orig_jiffies = jiffies;
        for (res = 0, try = 0; try <= adapter->retries; try++) {
            res = adapter->algo->smbus_xfer(adapter, addr, flags,
                            read_write, command,
                            protocol, data);
            if (res != -EAGAIN)
                break;
            if (time_after(jiffies,
                       orig_jiffies + adapter->timeout))
                break;
        }
        i2c_unlock_adapter(adapter);

        if (res != -EOPNOTSUPP || !adapter->algo->master_xfer)
            goto trace;
        /*
         * 如果适配器没有实现SMBus操作的本地支持，则回退到i2c_smbus_xfer_emulated。
         */
    }

    res = i2c_smbus_xfer_emulated(adapter, addr, flags, read_write,
                      command, protocol, data);

trace:
    /* 如果启用，则回复跟踪点取决于读写。*/
    trace_smbus_reply(adapter, addr, flags, read_write,
              command, protocol, data);
    trace_smbus_result(adapter, addr, flags, read_write,
               command, protocol, res);

    return res;
}

i2c_imx_xfer

smbus_xfer进行 SMBus 传输
/driver/i2c/busses/i2c-imx.c
这个函数是用于在i.MX平台的I2C适配器上执行数据传输操作。它是i.MX系列芯片的I2C驱动程序中的一部分。
该函数的作用如下：
开始I2C传输：调用i2c_imx_start函数启动I2C传输。它会发送起始条件（START）信号。
读写数据：对于每个消息（msgs数组中的每个元素），根据消息的属性进行读写操作。如果消息的flags标志指示要读取数据，则调用i2c_imx_read函数进行读取；否则，根据DMA的可用性调用适当的写入函数进行写入操作，可以选择使用DMA写入或普通写入。
停止I2C传输：调用i2c_imx_stop函数停止I2C传输。它会发送停止条件（STOP）信号。
返回结果：根据传输的成功与否，返回相应的结果。如果传输失败，则返回负数表示错误；否则，返回传输的消息数量。

该函数在I2C传输过程中还输出一些调试信息，例如控制寄存器（I2CR）和状态寄存器（I2SR）的值，以及传输消息的序号和结果状态。
总体而言，这个函数负责管理i.MX平台上的I2C传输过程，处理起始条件、读写数据以及停止条件，以实现与I2C设备的通信。

static int i2c_imx_xfer(struct i2c_adapter *adapter,
                        struct i2c_msg *msgs, int num)
{
    unsigned int i, temp;
    int result;
    bool is_lastmsg = false;
    struct imx_i2c_struct *i2c_imx = i2c_get_adapdata(adapter);

    dev_dbg(&i2c_imx->adapter.dev, "<%s>\n", __func__);

    /* Start I2C transfer */
    result = i2c_imx_start(i2c_imx); // 开始I2C传输
    if (result)
        goto fail0;

    /* read/write data */
    for (i = 0; i < num; i++) { // 读写数据
        if (i == num - 1)
            is_lastmsg = true;

        if (i) {
            dev_dbg(&i2c_imx->adapter.dev,
                "<%s> repeated start\n", __func__);
            temp = imx_i2c_read_reg(i2c_imx, IMX_I2C_I2CR);
            temp |= I2CR_RSTA; // 重复启动
            imx_i2c_write_reg(temp, i2c_imx, IMX_I2C_I2CR);
            result =  i2c_imx_bus_busy(i2c_imx, 1);
            if (result)
                goto fail0;
        }
        dev_dbg(&i2c_imx->adapter.dev,
            "<%s> transfer message: %d\n", __func__, i);

        /* write/read data */
#ifdef CONFIG_I2C_DEBUG_BUS
        temp = imx_i2c_read_reg(i2c_imx, IMX_I2C_I2CR);
        dev_dbg(&i2c_imx->adapter.dev,
            "<%s> CONTROL: IEN=%d, IIEN=%d, MSTA=%d, MTX=%d, TXAK=%d, RSTA=%d\n",
            __func__,
            (temp & I2CR_IEN ? 1 : 0), (temp & I2CR_IIEN ? 1 : 0),
            (temp & I2CR_MSTA ? 1 : 0), (temp & I2CR_MTX ? 1 : 0),
            (temp & I2CR_TXAK ? 1 : 0), (temp & I2CR_RSTA ? 1 : 0));
        temp = imx_i2c_read_reg(i2c_imx, IMX_I2C_I2SR);
        dev_dbg(&i2c_imx->adapter.dev,
            "<%s> STATUS: ICF=%d, IAAS=%d, IBB=%d, IAL=%d, SRW=%d, IIF=%d, RXAK=%d\n",
            __func__,
            (temp & I2SR_ICF ? 1 : 0), (temp & I2SR_IAAS ? 1 : 0),
            (temp & I2SR_IBB ? 1 : 0), (temp & I2SR_IAL ? 1 : 0),
            (temp & I2SR_SRW ? 1 : 0), (temp & I2SR_IIF ? 1 : 0),
            (temp & I2SR_RXAK ? 1 : 0));
#endif
        if (msgs[i].flags & I2C_M_RD)
            result = i2c_imx_read(i2c_imx, &msgs[i], is_lastmsg); // 读取
        else {
            if (i2c_imx->dma && msgs[i].len >= DMA_THRESHOLD)
                result = i2c_imx_dma_write(i2c_imx, &msgs[i]); // DMA写
            else
                result = i2c_imx_write(i2c_imx, &msgs[i]); // 写
        }
        if (result)
            goto fail0;
    }

fail0:
    /* Stop I2C transfer */
    i2c_imx_stop(i2c_imx); // 停止I2C传输

    dev_dbg(&i2c_imx->adapter.dev, "<%s> exit with: %s: %d\n", __func__,
        (result < 0) ? "error" : "success msg",
            (result < 0) ? result : num);
    return (result < 0) ? result : num;
}

i2c_smbus_xfer_emulated

ov2640_s_register->i2c_smbus_write_byte_data->i2c_smbus_xfer->i2c_smbus_xfer_emulated
函数名为 i2c_smbus_xfer，接受一个 i2c_adapter 结构体指针 adapter、一个 u16 类型的地址 addr、一个 unsigned short 类型的标志位 flags、一个 char 类型的读写操作 read_write、一个 u8 类型的命令 command、一个 int 类型的协议 protocol，以及一个 union i2c_smbus_data 联合体指针 data 作为参数。
函数的主要功能如下：
执行跟踪点追踪，记录有关 SMBus 写入和读取操作的信息。
对标志位进行处理，只保留 I2C_M_TEN、I2C_CLIENT_PEC 和 I2C_CLIENT_SCCB 三个标志位。
如果适配器的算法中实现了 smbus_xfer 函数，则使用该函数进行 SMBus 传输。在仲裁丢失的情况下自动重试，直到达到最大重试次数或超时。
如果适配器的算法没有实现 smbus_xfer 函数或返回 -EOPNOTSUPP，则回退到使用 i2c_smbus_xfer_emulated 函数进行传输。
执行跟踪点追踪，记录有关 SMBus 回复和结果的信息。
返回传输的结果。
该函数的作用是通过使用 I2C 总线进行 SMBus 传输。它根据适配器的支持情况选择合适的传输方法，并处理重试和回退逻辑，最终返回传输的结果。

static s32 i2c_smbus_xfer_emulated(struct i2c_adapter *adapter, u16 addr,
                   unsigned short flags,
                   char read_write, u8 command, int size,
                   union i2c_smbus_data *data)
{
    /* 需要生成一系列的消息。在写入的情况下，我们只需要使用一个消息；在读取时，我们需要两个消息。我们使用合理的默认值初始化大多数内容，以使下面的代码更简单。 */
    unsigned char msgbuf0[I2C_SMBUS_BLOCK_MAX+3]; // 第一个消息的缓冲区
    unsigned char msgbuf1[I2C_SMBUS_BLOCK_MAX+2]; // 第二个消息的缓冲区
    int num = read_write == I2C_SMBUS_READ ? 2 : 1; // 消息数量
    int i;
    u8 partial_pec = 0; // 部分PEC
    int status;
    struct i2c_msg msg[2] = {
        {
            .addr = addr, // 地址
            .flags = flags, // 标志
            .len = 1, // 长度
            .buf = msgbuf0, // 缓冲区
        }, {
            .addr = addr, // 地址
            .flags = flags | I2C_M_RD, // 标志
            .len = 0, // 长度
            .buf = msgbuf1, // 缓冲区
        },
    };


    msgbuf0[0] = command; // 命令
    switch (size) { // 根据size的值进行判断
    case I2C_SMBUS_QUICK: // 快速模式
        msg[0].len = 0; // 长度为0
        /* 特殊情况：读写字段用作数据 */
        msg[0].flags = flags | (read_write == I2C_SMBUS_READ ?
                    I2C_M_RD : 0); // 标志
        num = 1; // 消息数量为1
        break;
    case I2C_SMBUS_BYTE: // 字节模式
        if (read_write == I2C_SMBUS_READ) {
            /* 特殊情况：只有读！ */
            msg[0].flags = I2C_M_RD | flags; // 标志
            num = 1; // 消息数量为1
        }
        break;
    case I2C_SMBUS_BYTE_DATA: // 字节数据模式
        if (read_write == I2C_SMBUS_READ)
            msg[1].len = 1; // 长度为1
        else {
            msg[0].len = 2; // 长度为2
            msgbuf0[1] = data->byte; // 数据
        }
        break;
    case I2C_SMBUS_WORD_DATA: // 字数据模式
        if (read_write == I2C_SMBUS_READ)
            msg[1].len = 2; // 长度为2
        else {
            msg[0].len = 3; // 长度为3
            msgbuf0[1] = data->word & 0xff; // 数据低位
            msgbuf0[2] = data->word >> 8; // 数据高位
        }
        break;

    case I2C_SMBUS_PROC_CALL: // 处理调用
        num = 2; /* 特殊情况 */
        read_write = I2C_SMBUS_READ; // 读操作
        msg[0].len = 3; // 长度为3
        msg[1].len = 2; // 长度为2
        msgbuf0[1] = data->word & 0xff; // 数据低位
        msgbuf0[2] = data->word >> 8; // 数据高位
        break;
    case I2C_SMBUS_BLOCK_DATA: // 块数据
        if (read_write == I2C_SMBUS_READ) {
            msg[1].flags |= I2C_M_RECV_LEN; // 接收长度
            msg[1].len = 1; /* 块长度将由底层总线驱动程序添加 */
        } else {
            msg[0].len = data->block[0] + 2; // 长度为块长度+2
            if (msg[0].len > I2C_SMBUS_BLOCK_MAX + 2) { // 如果长度大于最大块长度+2
                dev_err(&adapter->dev,
                    "Invalid block write size %d\n", // 输出错误信息
                    data->block[0]);
                return -EINVAL; // 返回错误
            }
            for (i = 1; i < msg[0].len; i++) // 遍历块
                msgbuf0[i] = data->block[i-1]; // 将块中的数据存入缓冲区
        }
        break;
    case I2C_SMBUS_BLOCK_PROC_CALL: // 块处理调用
        num = 2; /* 另一种特殊情况 */
        read_write = I2C_SMBUS_READ; // 读操作
        if (data->block[0] > I2C_SMBUS_BLOCK_MAX) { // 如果块长度大于最大块长度
            dev_err(&adapter->dev,
                "Invalid block write size %d\n", // 输出错误信息
                data->block[0]);
            return -EINVAL; // 返回错误
        }
        msg[0].len = data->block[0] + 2; // 长度为块长度+2
        for (i = 1; i < msg[0].len; i++) // 遍历块
            msgbuf0[i] = data->block[i-1]; // 将块中的数据存入缓冲区
        msg[1].flags |= I2C_M_RECV_LEN; // 接收长度
        msg[1].len = 1; /* 块长度将由底层总线驱动程序添加 */
        break;
    case I2C_SMBUS_I2C_BLOCK_DATA: // I2C块数据
        if (read_write == I2C_SMBUS_READ) {
            msg[1].len = data->block[0]; // 长度为块长度
        } else {
            msg[0].len = data->block[0] + 1; // 长度为块长度+1
            if (msg[0].len > I2C_SMBUS_BLOCK_MAX + 1) { // 如果长度大于最大块长度+1
                dev_err(&adapter->dev,
                    "Invalid block write size %d\n", // 输出错误信息
                    data->block[0]);
                return -EINVAL; // 返回错误
            }
            for (i = 1; i <= data->block[0]; i++) // 遍历块
                msgbuf0[i] = data->block[i]; // 将块中的数据存入缓冲区
        }
        break;
    default:
        dev_err(&adapter->dev, "Unsupported transaction %d\n", size); // 输出错误信息
        return -EOPNOTSUPP; // 返回错误
    }
    // 判断是否需要计算PEC
    i = ((flags & I2C_CLIENT_PEC) && size != I2C_SMBUS_QUICK
                      && size != I2C_SMBUS_I2C_BLOCK_DATA);
    if (i) {
        /* 如果第一个消息是写，则计算PEC */
        if (!(msg[0].flags & I2C_M_RD)) {
            if (num == 1) /* 只有写操作 */
                i2c_smbus_add_pec(&msg[0]);
            else /* 先写后读 */
                partial_pec = i2c_smbus_msg_pec(0, &msg[0]);
        }
        /* 如果最后一个消息是读，则请求PEC */
        if (msg[num-1].flags & I2C_M_RD)
            msg[num-1].len++;
    }

    status = i2c_transfer(adapter, msg, num); // 发送消息
    if (status < 0)
        return status; // 发送失败，返回错误

    /* 如果最后一个消息是读，则检查PEC */
    if (i && (msg[num-1].flags & I2C_M_RD)) {
        status = i2c_smbus_check_pec(partial_pec, &msg[num-1]);
        if (status < 0)
            return status;
    }


    // 根据读写类型进行操作
    if (read_write == I2C_SMBUS_READ)
        switch (size) {
        case I2C_SMBUS_BYTE:
            data->byte = msgbuf0[0]; // 将缓冲区中的数据存入data中
            break;
        case I2C_SMBUS_BYTE_DATA:
            data->byte = msgbuf1[0]; // 将缓冲区中的数据存入data中
            break;
        case I2C_SMBUS_WORD_DATA:
        case I2C_SMBUS_PROC_CALL:
            data->word = msgbuf1[0] | (msgbuf1[1] << 8); // 将缓冲区中的数据存入data中
            break;
        case I2C_SMBUS_I2C_BLOCK_DATA:
            for (i = 0; i < data->block[0]; i++)
                data->block[i+1] = msgbuf1[i]; // 将缓冲区中的数据存入data中
            break;
        case I2C_SMBUS_BLOCK_DATA:
        case I2C_SMBUS_BLOCK_PROC_CALL:
            for (i = 0; i < msgbuf1[0] + 1; i++)
                data->block[i] = msgbuf1[i]; // 将缓冲区中的数据存入data中
            break;
        }
    return 0;
}

i2c_transfer

ov2640_s_register->i2c_smbus_write_byte_data->i2c_smbus_xfer->i2c_smbus_xfer_emulated->i2c_transfer
这段代码实现了在I2C总线上进行传输的函数i2c_transfer。它是一个通用的I2C传输函数，用于向I2C设备发送一系列消息，并返回传输的结果。
函数首先检查适配器是否支持master_xfer函数，该函数用于执行实际的传输操作。如果适配器支持该函数，将进行以下步骤：
如果当前在原子上下文中或者中断被禁止，函数尝试获取适配器的锁定。如果无法获取锁定，表示有其他I2C活动正在进行中，函数返回-EAGAIN表示稍后重试。
如果当前不在原子上下文中且中断未被禁止，函数获取适配器的锁定。
调用__i2c_transfer函数执行实际的传输操作，传递适配器、消息数组和消息数量作为参数。
释放适配器的锁定。
返回传输的结果。
如果适配器不支持master_xfer函数，则函数打印一条调试信息并返回-EOPNOTSUPP表示不支持I2C级别的传输操作。
需要注意的是，这段代码中存在一些注释提到了错误报告模型的弱点，包括在从设备接收字节后出现错误时无法报告接收到的字节数量，以及在向从设备传输字节后收到NAK时无法报告已传输的字节数量。这些弱点需要在实际使用中进行进一步的考虑和处理。
总体而言，这段代码提供了一个通用的I2C传输函数，可以在适配器支持master_xfer函数的情况下进行传输操作，并返回传输的结果。

int i2c_transfer(struct i2c_adapter *adap, struct i2c_msg *msgs, int num)
{
    int ret;

    /* REVISIT the fault reporting model here is weak:
     * 
     *  - 当我们从从设备接收N个字节后出现错误时，没有办法报告“N”。
     * 
     *  - 当我们向从设备传输N个字节后收到NAK时，没有办法报告“N”...或者让主设备继续执行此组合消息的其余部分，如果这是适当的响应。
     * 
     *  - 例如，“num”为2，我们成功完成第一个消息，但在第二个消息的部分中出现错误，不清楚是否应将其报告为一个（丢弃第二个消息的状态）或errno（丢弃第一个消息的状态）。
     */

    if (adap->algo->master_xfer) {
#ifdef DEBUG
        for (ret = 0; ret < num; ret++) {
            dev_dbg(&adap->dev, "master_xfer[%d] %c, addr=0x%02x, "
                "len=%d%s\n", ret, (msgs[ret].flags & I2C_M_RD)
                ? 'R' : 'W', msgs[ret].addr, msgs[ret].len,
                (msgs[ret].flags & I2C_M_RECV_LEN) ? "+" : "");
        }
#endif

        if (in_atomic() || irqs_disabled()) {
            ret = i2c_trylock_adapter(adap);
            if (!ret)
                /* I2C活动正在进行中。 */
                return -EAGAIN;
        } else {
            i2c_lock_adapter(adap);
        }

        ret = __i2c_transfer(adap, msgs, num);
        i2c_unlock_adapter(adap);

        return ret;
    } else {
        dev_dbg(&adap->dev, "I2C level transfers not supported\n");
        return -EOPNOTSUPP;
    }
}

__i2c_transfer

ov2640_s_register->i2c_smbus_write_byte_data->i2c_smbus_xfer->i2c_smbus_xfer_emulated->i2c_transfer->__i2c_transfer
这个函数用于在给定的I2C适配器上执行一系列I2C消息的传输操作。
函数的主要步骤如下：
检查适配器的特殊特性：如果适配器具有特殊的quirks（特性），则调用i2c_check_for_quirks函数检查传入的消息是否需要特殊处理。如果需要特殊处理，返回错误码-EOPNOTSUPP表示不支持。
启用跟踪：根据跟踪选项的状态，决定是否启用消息跟踪。如果启用了消息跟踪，使用trace_i2c_read和trace_i2c_write函数跟踪每个读取或写入消息的详细信息。
重试机制：在给定的重试次数范围内，循环执行适配器的master_xfer函数来执行I2C传输。如果返回值不是-EAGAIN（表示仲裁丢失），或者超过了指定的超时时间，跳出循环。
结果跟踪：根据跟踪选项的状态，决定是否启用结果跟踪。如果启用了结果跟踪，使用trace_i2c_reply和trace_i2c_result函数跟踪每个读取消息的响应以及整体传输结果。
返回结果：返回传输操作的结果。

总体而言，该函数负责管理I2C传输过程中的重试机制和结果跟踪，并调用适配器的master_xfer函数执行实际的传输操作。它还提供了消息跟踪的选项，以便在需要时记录传输的详细信息。

int __i2c_transfer(struct i2c_adapter *adap, struct i2c_msg *msgs, int num)
{
    unsigned long orig_jiffies;
    int ret, try;

    if (adap->quirks && i2c_check_for_quirks(adap, msgs, num))
        return -EOPNOTSUPP;

    /* i2c_trace_msg gets enabled when tracepoint i2c_transfer gets
     * enabled.  This is an efficient way of keeping the for-loop from
     * being executed when not needed.
     */
    if (static_key_false(&i2c_trace_msg)) {
        int i;
        for (i = 0; i < num; i++)
            if (msgs[i].flags & I2C_M_RD)
                trace_i2c_read(adap, &msgs[i], i);
            else
                trace_i2c_write(adap, &msgs[i], i);
    }

    /* Retry automatically on arbitration loss */
    orig_jiffies = jiffies;
    for (ret = 0, try = 0; try <= adap->retries; try++) {
        ret = adap->algo->master_xfer(adap, msgs, num);
        if (ret != -EAGAIN)
            break;
        if (time_after(jiffies, orig_jiffies + adap->timeout))
            break;
    }

    if (static_key_false(&i2c_trace_msg)) {
        int i;
        for (i = 0; i < ret; i++)
            if (msgs[i].flags & I2C_M_RD)
                trace_i2c_reply(adap, &msgs[i], i);
        trace_i2c_result(adap, i, ret);
    }

    return ret;
}

设置ov2640的电源ov2640_s_power

这段代码是用于设置ov2640相机设备的电源状态的函数。
函数名为ov2640_s_power，接受一个v4l2_subdev结构体指针和一个整数on作为参数。
函数的主要功能如下：
从v4l2_subdev结构体中获取i2c_client结构体指针，该结构体用于表示I2C设备。
使用i2c_client结构体指针获取soc_camera_subdev_desc结构体指针，该结构体用于描述相机子设备。
从i2c_client结构体指针中获取ov2640_priv结构体指针，该结构体是ov2640相机设备的私有数据。
调用soc_camera_set_power函数，将dev（设备）、ssdd（相机子设备描述）、priv->clk（时钟）和on（电源状态）作为参数，以设置ov2640相机设备的电源状态。
返回soc_camera_set_power函数的返回值。
该函数的作用是通过调用soc_camera_set_power函数来设置ov2640相机设备的电源状态。

// 设置ov2640的电源状态
static int ov2640_s_power(struct v4l2_subdev *sd, int on)
{
    // 获取i2c_client结构体
    struct i2c_client *client = v4l2_get_subdevdata(sd);
    // 获取soc_camera_subdev_desc结构体
    struct soc_camera_subdev_desc *ssdd = soc_camera_i2c_to_desc(client);
    // 获取ov2640_priv结构体
    struct ov2640_priv *priv = to_ov2640(client);

    // 设置ov2640的电源状态
    return soc_camera_set_power(&client->dev, ssdd, priv->clk, on);
}

/include/media/soc_camera.h
// 设置摄像头电源状态
static inline int soc_camera_set_power(struct device *dev,
        struct soc_camera_subdev_desc *ssdd, struct v4l2_clk *clk, bool on)
{
    return on ? soc_camera_power_on(dev, ssdd, clk) // 打开电源
          : soc_camera_power_off(dev, ssdd, clk); // 关闭电源
}

/driver/media/platform/soc_camera.c
这两个函数用于相机电源的开启和关闭操作。下面是对这两个函数的概括总结：
soc_camera_power_on函数用于打开相机的电源。
如果提供了时钟，并且未平衡电源或时钟状态未设置，则使能时钟。
使能寄存器。
如果存在电源回调函数，则调用电源回调函数使能相机电源。
如果上述操作都成功，则返回0。
如果有任何步骤失败，则执行相应的错误处理操作，包括禁用寄存器和时钟，并返回错误码。
soc_camera_power_off函数用于关闭相机的电源。
如果存在电源回调函数，则调用电源回调函数关闭相机电源。
禁用寄存器。
如果提供了时钟，并且未平衡电源或时钟状态已设置，则禁用时钟。
返回执行过程中的任何错误码。
这两个函数在相机驱动中用于管理相机设备的电源控制，包括使能和禁用电源和相关的时钟和寄存器。

int soc_camera_power_on(struct device *dev, struct soc_camera_subdev_desc *ssdd,
            struct v4l2_clk *clk)
{
    int ret;
    bool clock_toggle;

    if (clk && (!ssdd->unbalanced_power ||
            !test_and_set_bit(0, &ssdd->clock_state))) { // 如果有时钟并且未平衡电源或时钟状态未设置
        ret = v4l2_clk_enable(clk); // 使能时钟
        if (ret < 0) {
            dev_err(dev, "Cannot enable clock: %d\n", ret); // 不能使能时钟
            return ret;
        }
        clock_toggle = true; // 时钟切换为真
    } else {
        clock_toggle = false; // 时钟切换为假
    }

    ret = regulator_bulk_enable(ssdd->sd_pdata.num_regulators,
                    ssdd->sd_pdata.regulators); // 使能寄存器
    if (ret < 0) {
        dev_err(dev, "Cannot enable regulators\n"); // 不能使能寄存器
        goto eregenable;
    }

    if (ssdd->power) { // 如果有电源
        ret = ssdd->power(dev, 1); // 使能电源
        if (ret < 0) {
            dev_err(dev,
                "Platform failed to power-on the camera.\n"); // 不能使能相机电源
            goto epwron;
        }
    }

    return 0;

epwron:
    regulator_bulk_disable(ssdd->sd_pdata.num_regulators,
                   ssdd->sd_pdata.regulators); // 禁用寄存器
eregenable:
    if (clock_toggle)
        v4l2_clk_disable(clk); // 禁用时钟

    return ret;
}

EXPORT_SYMBOL(soc_camera_power_on);

/**
 * soc_camera_power_off() - 关闭相机电源
 * @dev: 设备
 * @ssdd: 相机子设备描述
 * @clk: 时钟
 * @return: 返回值
 */
int soc_camera_power_off(struct device *dev, struct soc_camera_subdev_desc *ssdd,
             struct v4l2_clk *clk)
{
    int ret = 0;
    int err;

    if (ssdd->power) { // 如果有电源
        err = ssdd->power(dev, 0); // 关闭电源
        if (err < 0) {
            dev_err(dev,
                "Platform failed to power-off the camera.\n"); // 不能关闭相机电源
            ret = err;
        }
    }

    err = regulator_bulk_disable(ssdd->sd_pdata.num_regulators,
                     ssdd->sd_pdata.regulators); // 禁用寄存器
    if (err < 0) {
        dev_err(dev, "Cannot disable regulators\n"); // 不能禁用寄存器
        ret = ret ? : err;
    }

    if (clk && (!ssdd->unbalanced_power || test_and_clear_bit(0, &ssdd->clock_state)))
        v4l2_clk_disable(clk); // 禁用时钟

    return ret;
}

如果文章对您有帮助，点赞👍支持，感谢🤝