Linux MIPI 摄像头驱动框架编写（RN6752解码芯片）

一、概述

在编写 MIPI 摄像头驱动之前，需要先了解 Media 子系统的链路关系，这里我就不介绍了，需要的看我之前的笔记：Linux Media 子系统链路分析。

理解 Media 子系统链路关系后，会发现 ISP 不论是在摄像头端，还是集成在 SOC 中，驱动程序都是差不多的。多观察一下开发板中的其他案例，便会明白 MIPI 摄像头驱动部分的程序就是一个 I2C 驱动程序，而 D-PHY 部分的驱动相关厂商已经编写好了，我们只需要通过 I2C 通道配置好摄像头相关的寄存器即可。

在 linux 中，摄像头驱动是基于 V4L2 框架进行实现的，所以在编写驱动之前，还需明白 V4L2 的框架是怎么回事，需要了解的可以看其他大佬的博客，这里我就不深入介绍了，主要内容还是程序的编写。V4L2 的框架如下图所示：

二、测试环境

  1. 开发板：RV1126
  2. ARM Linux 版本：4.19.111
  3. 驱动芯片：RN6752V1
  4. MIPI 通道的数据格式：YUV

三、添加驱动文件

  1. 创建驱动文件
    在 SDK 的 sdk/kernel/drivers/media/i2c/ 目录下添加 rn6752.c 文件，内容如下

    		/* 驱动名称 */
    		#define DRIVER_NAME "rn6752"
    		 
    		/* 驱动版本信息 */
    		#define DRIVER_VERSION			KERNEL_VERSION(0, 0x00, 0x01)
    		 
    		/**
    		* @brief 系统检测到与该驱动程序匹配的 I2C 设备时
    		* @param client 指向 I2C 客户端结构体的指针。该结构体包含了有关 I2C 设备的信息，如设备地址、总线信息等
    		* @param id 指向 I2C 设备 ID 的指针。这个参数用于在多个相同类型的设备中进行区分和匹配
    		* @return 返回初始化结构
    		*/
    		static int rn6752_probe(struct i2c_client *client, const struct i2c_device_id *id)
    		{
    			struct device *dev = &client->dev;
    		 
    			/* 打印驱动的版本信息的函数，其作用相当于 printk() 函数 */
    			dev_info(dev, "driver version: %02x.%02x.%02x", DRIVER_VERSION >> 16,
    				(DRIVER_VERSION & 0xff00) >> 8,	DRIVER_VERSION & 0x00ff);
    			
    			return 0;
    		}
    		 
    		/**
    		* @brief 当设备驱动被删除释放时，执行此函数
    		* @param client 指向 I2C 客户端结构体的指针。该结构体包含了有关 I2C 设备的信息，如设备地址、总线信息等
    		* @return 返回操作结果
    		*/
    		static int rn6752_remove(struct i2c_client *client)
    		{
    		 
    			return 0;
    		}
    		 
    		/* 设备树节点匹配表格，与设备树中的节点描述信息一样时，匹配成功 */
    		#if IS_ENABLED(CONFIG_OF)
    		static const struct of_device_id rn6752_of_match[] = {
    			{ .compatible = "richnex,rn6752v1" },
    			{ /* sentinel */ },
    		};
    		MODULE_DEVICE_TABLE(of, rn6752_of_match);
    		#endif
    		 
    		/* 设备 ID 表格，与设备名称一样时匹配成功，主要用于低版本linux内核的匹配方式 */
    		static const struct i2c_device_id rn6752_match_id[] = {
    			{ "richnex,rn6752v1", 0 },
    			{ /* sentinel */ },
    		};
    		 
    		/* 描述和注册一个 I2C 设备驱动程序 */
    		static struct i2c_driver rn6752_i2c_driver = {
    			.driver = {                                             /* 驱动程序信息的子结构体 */
    				.name	= DRIVER_NAME,                              /* 设置驱动程序的名称 */
    				.of_match_table = of_match_ptr(rn6752_of_match),    /* 用于匹配设备树节点的表格 */
    			},
    			.probe		= rn6752_probe,                 /* I2C 设备被检测到时进行设备初始化和处理 */
    			.remove		= rn6752_remove,                /* I2C 设备从系统中移除时进行清理和资源释放 */
    			.id_table	= rn6752_match_id,              /* I2C 设备 ID 表格，平台设备匹配方式之一，用设备和驱动的名称进行匹配 */
    		};
    		 
    		static int __init sensor_mod_init(void)
    		{
    			/* 注册 I2C 驱动程序 */
    			return i2c_add_driver(&rn6752_i2c_driver);
    		}
    		 
    		static void __exit sensor_mod_exit(void)
    		{
    			/* 注销 I2C 驱动程序 */
    			i2c_del_driver(&rn6752_i2c_driver);
    		}
    		 
    		device_initcall_sync(sensor_mod_init);      /* 注册一个设备初始化函数 */
    		module_exit(sensor_mod_exit);               /* 注销一个设备初始化函数 */
    		 
    		MODULE_AUTHOR("jiaozhu <cn_jiaozhu@qq.com>");
    		MODULE_DESCRIPTION("RN6752 CMOS Image Sensor driver");

    注意： 这里的代码是 I2C 驱动的基础，有不明白的小伙伴可以参看相关资料，也可以看我之前写的一些驱动笔记

  2. 添加编译选项
    在 SDK 的 sdk/kernel/drivers/media/i2c/Makefile 文件中添加 obj-$(CONFIG_VIDEO_RN6752V1) += rn6752.o，如下图所示

  3. 添加配置信息
    在 SDK 的 sdk/kernel/drivers/media/i2c/Kconfig 文件中添加配置信息，内容如下

    		config VIDEO_RN6752V1
    		        tristate "Richnex RN6752V1 sensor support"
    		        depends on I2C && VIDEO_V4L2 && VIDEO_V4L2_SUBDEV_API
    		        depends on MEDIA_CAMERA_SUPPORT
    		        help
    		          This is a Video4Linux2 sensor driver for the Sony
    		          RN6752V1 camera.
    		 
    		          To compile this driver as a module, choose M here: the
    		          module will be called rn6752v1.

  4. 打开 RN6752 驱动的编译选项
    在对应的.config 文件或 make menuconfig 图形配置界面中打开 RN6752 的驱动程序，完后会得到 CONFIG_VIDEO_RN6752V1 = y 的信息

  5. 添设备树信息
    在 SDK 的 sdk/kernel/arch/arm/boot/dts/rv1126-alientek.dts 文件的 I2C 节点中添加 RN6752 解码芯片的设备信息，内容如下

    		rn6752: rn6752@2c {
    		        compatible = "richnex,rn6752v1";
    		        reg = <0x2c>;
    		        clocks = <&cru CLK_MIPICSI_OUT>;
    		        clock-names = "xvclk";
    		        power-domains = <&power RV1126_PD_VI>;
    		        pinctrl-names = "rockchip,camera_default";
    		        pinctrl-0 = <&mipicsi_clk0>;
    		        avdd-supply = <&vcc_avdd>;
    		        dovdd-supply = <&vcc_dovdd>;
    		        dvdd-supply = <&vcc_dvdd>;
    		        pwdn-gpios = <&gpio1 RK_PD4 GPIO_ACTIVE_HIGH>;
    		        reset-gpios = <&gpio4 RK_PA0 GPIO_ACTIVE_LOW>;
    		        rockchip,camera-hdr-mode = <0>;
    		        rockchip,camera-module-index = <0>;
    		        rockchip,camera-module-facing = "front";
    		        rockchip,camera-module-name = "abcd";
    		        rockchip,camera-module-lens-name = "a-bc-d";
    		        port {
    		            ucam_out0: endpoint {
    		                remote-endpoint = <&mipi_in_ucam0>;
    		                data-lanes = <1 2 3 4>;
    		            };
    		        };
    		    };

  6. 完成以上内容后，准备工作基本完成了，编译并重写烧写内核程序后，会在启动日志中打印版本信息，如下图所示

四、probe 函数实现

  1. 内存申请
    首先需要申请一块内存，用于存放 RN6752 的结构体

    		/* 为设备分配内存，并将内存与设备进行关联。在驱动程序退出时，内存会自动被释放。被称为“设备内存管理” */
    			rn6752 = devm_kzalloc(dev, sizeof(*rn6752), GFP_KERNEL);
    			if (!rn6752)
    			{
    				dev_err(dev, "Memory control request failed\n");
    				return -ENOMEM;
    			}

  2. 获取设备树配置的信息

    		/* 获取设备树信息 */
    			ret = rn6752_device_tree_info(rn6752);
    			if (ret != 0)
    				return -EINVAL;

  3. 保留驱动的所有帧格式，方便在其他函数中使用

    		/* rn6752_mipi_framesizes 是 rn6752 mipi 通信支持的所有帧格式 */
    		    rn6752->framesize_cfg = rn6752_mipi_framesizes;
    			rn6752->cfg_num = ARRAY_SIZE(rn6752_mipi_framesizes);
    			/* 获取摄像头传感器支持的图像帧格式 */
    			rn6752_get_default_format(rn6752, &rn6752->format);
    			rn6752->frame_size = &rn6752->framesize_cfg[0];             /* 设置帧大小 */
    			rn6752->format.width = rn6752->framesize_cfg[0].width;      /* 设置宽度 */
    			rn6752->format.height = rn6752->framesize_cfg[0].height;    /* 设置高度 */
    			rn6752->fps = DIV_ROUND_CLOSEST(rn6752->framesize_cfg[0].max_fps.denominator,
    			rn6752->framesize_cfg[0].max_fps.numerator);        		/* 设置最大帧速率 */

  4. 初始化互斥锁

    		mutex_init(&rn6752->lock);

  5. 注册一个V4L2子设备

    		v4l2_i2c_subdev_init(sd, client, &rn6752_subdev_ops);

  6. 绑定硬件操作函数

    		ret = rn6752_initialize_controls(rn6752);
    			if (ret)
    			{
    				dev_info(dev, "V4l2 control menu initialization failed");
    				goto err_destroy_mutex;
    			}

    注意： 此函数的作用是绑定硬件部分的控制功能，也就是或可以通过相应的设备节点更改设备的引荐参数，比如亮度、对比度、饱和度、色调等。
    可以通过命令 v4l2-ctl -d /dev/v4l-subdevX --list-ctrls 查看，如下图所示：

  7. 关联 V4l2 子设备内部操作函数

    		/* 关联子设备的内部操作函数，用于打开摄像头操作 */
    			sd->internal_ops = &rn6752_subdev_internal_ops;
    		    sd->flags |= V4L2_SUBDEV_FL_HAS_DEVNODE |           /* 设备有对应的设备节点文件，可以通过该文件进行访问 */
    				     V4L2_SUBDEV_FL_HAS_EVENTS;                 /* 设备具有事件机制，可以作为事件源供其他驱动程序使用 */

  8. 打开电源
    mipi 设备一般都有复位引脚和休眠引脚，工作是需要对相应的引脚进行操作

    		/* 打开设备的电源 */
    			ret = __rn6752_power_on(rn6752);
    			if (ret)
    				goto err_free_handler;

  9. 读取设备产品号
    通过读取 mipi 设备的产品 id 进行对比，判断初始化时，设备是否连接，最终确定时候正常加载驱动

    		/* 通过读取 RN6752 的产品 ID 判断设备是否存在 */
    			ret = rn6752_check_sersor_id(rn6752);
    			if (ret)
    				goto err_power_off;

  10. 创建 media 设备

    		rn6752->pad.flags = MEDIA_PAD_FL_SOURCE;            /* 表明该子设备是媒体管道中的源设备，即数据的起始点 */
    			sd->entity.function = MEDIA_ENT_F_CAM_SENSOR;       /* 表示该实体是一个相机传感器 */
    			ret = media_entity_pads_init(&sd->entity, 1, &rn6752->pad);     /* 初始化 sd->entity 媒体实体的 pads（端口）属性 */
    			if (ret < 0) {
    				dev_err(dev, "Media pad port initialization failed\n");
    				goto err_power_off;
    			}

  11. 将传感器子设备添加到V4L2异步子系统中
    这里需要注意一下，在执行此函数之前，在系统中是不会生成 media 设备节点的

    		/* 根据设备树提供的信息，判断摄像头的方向 */
    		    memset(facing, 0, sizeof(facing));
    			if (strcmp(rn6752->module_facing, "back") == 0)
    				facing[0] = 'b';
    			else
    				facing[0] = 'f';
    		 
    		    /* 名称格式如 m00_f_rn6752 1-002c:bus */
    			snprintf(sd->name, sizeof(sd->name), "m%02d_%s_%s %s", 
    					rn6752->module_index, facing, DRIVER_NAME, dev_name(sd->dev));
    			/* 将传感器子设备添加到V4L2异步子系统中，以便能够与其他V4L2组件进行交互。 */
    			/* 它会自动设置子设备的相关回调函数，并与异步框架进行适当的关联，以管理传感器的采集和控制操作 */
    			ret = v4l2_async_register_subdev_sensor_common(sd);
    			if (ret)
    			{
    				dev_err(dev, "Failed to add sensor to V4L2 asynchronous subsystem\n");
    				goto err_clean_entity;
    			}

    注意： 在 RV1126 开发板中，创建 media 设备时，需要注意 mipi 连接的通道，连接 mipi
    csi0 时，需要获取设备的数据格式，否则会出现内存地址错误。解决此错误的方法是在 rn6752_get_fmt 函数中默认一个类型值即可，如下图所示：

  12. 进入休眠模式
    完成初始化后，使传感器进入休眠模式

    		 /* 完成初始化后，使 rn6752 进入睡眠模式 */
    			rn6752->power_on = false;
    		    if (!IS_ERR(rn6752->pwdn_gpio))
    						gpiod_set_value_cansleep(rn6752->pwdn_gpio, 1);

到此整个驱动程序就算完成了，由于内容较多，所以分成了两篇笔记，相关的控制函数的实现请看下一篇笔记，下面是 MIPI 驱动框架的程序

五、程序源码

rn6752.c

#include <linux/clk.h>
#include <linux/delay.h>
#include <linux/err.h>
#include <linux/gpio/consumer.h>
#include <linux/init.h>
#include <linux/interrupt.h>
#include <linux/io.h>
#include <linux/i2c.h>
#include <linux/kernel.h>
#include <linux/media.h>
#include <linux/module.h>
#include <linux/of.h>
#include <linux/of_graph.h>
#include <linux/regulator/consumer.h>
#include <linux/slab.h>
#include <linux/uaccess.h>
#include <linux/videodev2.h>
#include <linux/version.h>
#include <linux/rk-camera-module.h>
#include <media/media-entity.h>
#include <media/v4l2-common.h>
#include <media/v4l2-ctrls.h>
#include <media/v4l2-device.h>
#include <media/v4l2-event.h>
#include <media/v4l2-fwnode.h>
#include <media/v4l2-image-sizes.h>
#include <media/v4l2-mediabus.h>
#include <media/v4l2-subdev.h>
 
/* 驱动名称 */
#define DRIVER_NAME "rn6752"
 
/* 驱动版本信息 */
#define DRIVER_VERSION			KERNEL_VERSION(0, 0x00, 0x01)
 
#define RN6752_XVCLK_CLOCK		37125000
	
#define RN6752_PIXEL_RATE		(120 * 1000 * 1000)
 
/* RN6752 产品 ID 的寄存器地址及默认值，用于判断设备是否存在 */
#define REG_SC_CHIP_ID_H		0xFE
#define REG_SC_CHIP_ID_L		0xFD
#define SENSOR_ID(_msb, _lsb)		((_msb) << 8 | (_lsb))
#define RN6752_ID				0x2601
#define REG_NULL			0xFFFF	/* Array end token */
 
struct rn6752_pixfmt {
	u32 code;
	/* Output format Register Value (REG_FORMAT_CTRL00) */
	struct sensor_register *format_ctrl_regs;
};
 
struct sensor_register {
	u16 addr;
	u8 value;
};
 
struct rn6752_framesize {
	u16 width;
	u16 height;
	struct v4l2_fract max_fps;
	u16 max_exp_lines;
	const struct sensor_register *regs;
};
 
static const char * const rn6752_supply_names[] = {
	"dovdd",	/* Digital I/O power */
	"avdd",		/* Analog power */
	"dvdd",		/* Digital core power */
};
 
#define RN6752_NUM_SUPPLIES ARRAY_SIZE(rn6752_supply_names)
 
struct rn6752 {
	struct i2c_client *client;              /* I2C 客户端结构体的指针，表示 RN6752 摄像头所连接的 I2C 设备 */
 
	struct v4l2_subdev subdev;              /* V4L2 子设备结构体，表示 RN6752 摄像头的 V4L2 子设备 */
	struct v4l2_ctrl_handler ctrls;         /* V4L2 控制器句柄，用于管理 RN6752 摄像头的各种控制器 */
	struct v4l2_ctrl *link_frequency;       /* V4L2 链路频率控制器，用于设置和获取 RN6752 摄像头的链路频率 */
	struct v4l2_fwnode_endpoint bus_cfg;    /* RN6752 摄像头的总线配置，包括数据线数量、数据线极性等信息 */
	struct v4l2_mbus_framefmt format;       /* V4L2 子设备帧格式结构体，表示 RN6752 摄像头支持的图像帧格式 */
 
	struct media_pad pad;                   /* 媒体子系统中的媒体端口结构体，表示与 RN6752 摄像头相关联的媒体端口 */
	
	struct gpio_desc *pwdn_gpio;            /* RN6752 摄像头的 pwdn GPIO 引脚 */
	struct gpio_desc *reset_gpio;           /* RN6752 摄像头的复位 GPIO 引脚 */
	struct regulator_bulk_data supplies[RN6752_NUM_SUPPLIES];   /* RN6752 摄像头使用的电源资源 */
	struct mutex lock;                      /* 互斥锁，用于保护并发访问摄像头设备 */
	
    unsigned int fps;                       /* RN6752 摄像头的帧率 */
	const struct rn6752_framesize *frame_size;          /* RN6752 摄像头支持的帧大小列表的指针 */
	const struct rn6752_framesize *framesize_cfg;       /* 当前 RN6752 摄像头所选择的帧大小的指针 */
	unsigned int cfg_num;                   /* RN6752 摄像头支持的帧大小的数量 */
	int streaming;                          /* RN6752 摄像头是否正在流式传输 */
	bool power_on;                          /* RN6752 摄像头的电源状态 */
	
	u32 module_index;                       /* RN6752 摄像头的模块索引 */
	const char *module_facing;              /* RN6752 摄像头面向的方向 */
	const char *module_name;                /* RN6752 摄像头的名称 */
	const char *len_name;                   /* RN6752 摄像头的镜头名称 */
 
	struct clk *xvclk;                      /* RN6752 摄像头使用的时钟资源 */
	unsigned int xvclk_frequency;           /* RN6752 摄像头的 xvclk 频率 */
};
 
 
static const struct rn6752_framesize rn6752_mipi_framesizes[] = {
 
};
 
static const s64 link_freq_menu_items[] = {
	594000000,
};
 
static const struct rn6752_pixfmt rn6752_formats[] = {
	{
		.code = MEDIA_BUS_FMT_UYVY8_2X8,
	}
};
 
static const char * const rn6752_test_pattern_menu[] = {
	"Disabled",
	"Vertical Color Bars",
};
 
/**
* @brief 从结构体中的成员指针获取包含该成员的结构体指针
*/
static inline struct rn6752 *to_rn6752(struct v4l2_subdev *sd)
{
	return container_of(sd, struct rn6752, subdev);
}
 
/**
* @brief 打开摄像头电源管理
* @param rn6752 摄像头结构体
* @return 返回摄像头电源设置结果
*/
static int __rn6752_power_on(struct rn6752 *rn6752)
{
	int ret;
	struct device *dev = &rn6752->client->dev;
 
	/* 打印一条调试信息 */
	dev_dbg(dev, "%s(%d)\n", __func__, __LINE__);
 
	/* 启用所有的供电器 */
	if (!IS_ERR(rn6752->supplies)) {
		ret = regulator_bulk_enable(RN6752_NUM_SUPPLIES, rn6752->supplies);
		if (ret < 0)
			dev_info(dev, "Failed to enable regulators\n");
 
		usleep_range(20000, 50000);
	}
 
	/* 首先将其引脚置为低电平（0），延迟一段时间，然后再将其引脚置为高电平（1），再次延迟一段时间 */
	if (!IS_ERR(rn6752->reset_gpio)) {
		gpiod_set_value_cansleep(rn6752->reset_gpio, 0);
		usleep_range(2000, 5000);
		gpiod_set_value_cansleep(rn6752->reset_gpio, 1);
		usleep_range(2000, 5000);
	}
 
    /* 使 RN6752 退出睡眠模式 */
	if (!IS_ERR(rn6752->pwdn_gpio)) {
		gpiod_set_value_cansleep(rn6752->pwdn_gpio, 0);
		usleep_range(2000, 5000);
	}
 
	/* 将 xvclk 的频率设置为 RN6752_XVCLK_CLOCK */
	if (!IS_ERR(rn6752->xvclk)) {
		ret = clk_set_rate(rn6752->xvclk, RN6752_XVCLK_CLOCK);
		if (ret < 0)
			dev_warn(dev, "Failed to set xvclk rate %d MHz\n", RN6752_XVCLK_CLOCK);
 
		ret = clk_get_rate(rn6752->xvclk);
		if (ret != RN6752_XVCLK_CLOCK)
			dev_warn(dev, "xvclk mismatched\n");
		
		/* 准备并启用 xvclk */
		ret = clk_prepare_enable(rn6752->xvclk);
		if (ret < 0)
		{
			dev_err(dev, "Failed to enable xvclk\n");
			return -EINVAL;
		}
			
	}
 
	rn6752->power_on = true;
	return 0;
}
 
/**
* @brief 关闭摄像头电源管理
* @param rn6752 摄像头结构体
* @return 返回摄像头电源设置结果
*/
static void __rn6752_power_off(struct rn6752 *rn6752)
{
	dev_info(&rn6752->client->dev, "%s(%d)\n", __func__, __LINE__);
	if (!IS_ERR(rn6752->xvclk))
		clk_disable_unprepare(rn6752->xvclk);
	if (!IS_ERR(rn6752->supplies))
		regulator_bulk_disable(RN6752_NUM_SUPPLIES, rn6752->supplies);
	if (!IS_ERR(rn6752->pwdn_gpio))
		gpiod_set_value_cansleep(rn6752->pwdn_gpio, 1);
	if (!IS_ERR(rn6752->reset_gpio))
		gpiod_set_value_cansleep(rn6752->reset_gpio, 0);
 
	rn6752->power_on = false;
}
 
/**
 * @brief 从 I2C 通道中读取一个字节的数据
 * @param client I2C 结构体指针
 * @param reg 寄存器地址
 * @param val 读取的数据
*/
static int rn6752_read(struct i2c_client *client, u8 reg, u8 *val)
{
	int ret = 0;
	struct i2c_msg msg[2];
 
	msg[0].addr = client->addr;
	msg[0].flags = 0;
	msg[0].buf = &reg;
	msg[0].len = 1;
 
	msg[1].addr = client->addr;
	msg[1].flags = I2C_M_RD;
	msg[1].buf = val;
	msg[1].len = 1;
 
	ret = i2c_transfer(client->adapter, msg, 2);
	if (ret != 2) {
		dev_err(&client->dev, "rn6752 read reg:0x%x failed !\n", reg);
		return -1;
	}
 
	return 0;
}
 
/**
* @brief 获取摄像头传感器的默认格式
* @param rn6752 摄像头传感器设备
* @param format 视频帧格式
*/
static void rn6752_get_default_format(struct rn6752 *rn6752,
				      struct v4l2_mbus_framefmt *format)
{
	format->width = rn6752->framesize_cfg[0].width;         /* 设置默认宽度 */
	format->height = rn6752->framesize_cfg[0].height;       /* 设置默认高度 */
	format->colorspace = V4L2_COLORSPACE_SRGB;              /* 设置默认色彩空间为标准的 sRGB 色彩空间 */
	format->code = rn6752_formats[0].code;                  /* 设置默认编码格式 */
	format->field = V4L2_FIELD_NONE;                        /* 设置默认场模式 */
}
 
/**
* @brief 获取摄像头的图像格式
* @param sd v4l2_subdev 结构体指针
* @param cfg v4l2_subdev_pad_config 结构体指针
* @param fmt v4l2_subdev_format 结构体指针
*/
static int rn6752_get_fmt(struct v4l2_subdev *sd,
			  struct v4l2_subdev_pad_config *cfg,
			  struct v4l2_subdev_format *fmt)
{
    printk(KERN_INFO "rn6752_get_fmt................................................\n");
    if (fmt->which == V4L2_SUBDEV_FORMAT_TRY) {
		fmt->format = *v4l2_subdev_get_try_format(sd, cfg, fmt->pad);
	} else {
		fmt->format.width = 1280;
		fmt->format.height = 720;
        fmt->format.code = MEDIA_BUS_FMT_SRGGB10_1X10;
		fmt->format.field = V4L2_FIELD_NONE;
		fmt->reserved[0] = 10;
	}
    return 0;
}
 
/* 定义V4L2子设备的内部操作函数 */
static const struct v4l2_subdev_internal_ops rn6752_subdev_internal_ops = {
	// .open = rn6752_open,
};
 
 
/* 结构体定义了控制器操作函数的回调函数 */
static const struct v4l2_ctrl_ops rn6752_ctrl_ops = {
	// .s_ctrl = rn6752_s_ctrl,
};
 
 
static const struct v4l2_subdev_core_ops rn6752_subdev_core_ops = {
// 	.ioctl = rn6752_ioctl,                                  /* 用于处理V4L2控制命令 */
// #ifdef CONFIG_COMPAT
// 	.compat_ioctl32 = rn6752_compat_ioctl32,                /* 在启用32位兼容模式时，用于处理32位兼容的V4L2控制命令 */
// #endif
// 	.s_power = rn6752_power,                                /* 用于控制子设备的电源状态 */
};
 
static const struct v4l2_subdev_video_ops rn6752_subdev_video_ops = {
	// .s_stream = rn6752_s_stream,                    /* 用于启动或停止视频流的函数 */
	// .g_mbus_config = rn6752_g_mbus_config,          /* 用于获取当前媒体总线配置的函数 */
	// .g_frame_interval = rn6752_g_frame_interval,    /* 用于获取当前帧间隔的函数 */
	// .s_frame_interval = rn6752_s_frame_interval,    /* 用于设置帧间隔的函数 */
};
 
static const struct v4l2_subdev_pad_ops rn6752_subdev_pad_ops = {
	// .enum_mbus_code = rn6752_enum_mbus_code,            /* 用于枚举所有支持的媒体总线编码和格式 */
	// .enum_frame_size = rn6752_enum_frame_sizes,         /* 用于枚举所有支持的图像尺寸 */
	// .enum_frame_interval = rn6752_enum_frame_interval,  /* 用于枚举所有支持的帧率和帧间隔 */
	.get_fmt = rn6752_get_fmt,                          /* 用于获取当前端口的图像格式 */
	// .set_fmt = rn6752_set_fmt,                          /* 用于设置当前端口的图像格式 */
};
 
 
static const struct v4l2_subdev_ops rn6752_subdev_ops = {
	.core  = &rn6752_subdev_core_ops,       /* 定义了V4L2子设备核心操作的函数指针。包括日志记录、事件订阅和取消订阅、控制命令等 */
	.video = &rn6752_subdev_video_ops,      /* 定义了V4L2子设备视频操作的函数指针。包括流开关、格式和帧间隔等参数的获取和设置 */
	.pad   = &rn6752_subdev_pad_ops,        /* 定义了V4L2子设备端口操作的函数指针。包括数据编解码格式、帧尺寸和帧间隔等相关参数的获取和设置 */
};
 
 
 
 
/**
* @brief 用于解析设备树配置的信息和引脚等
* @param rn6752 摄像头结构体
* @return 返回执行结果
*/
static int rn6752_device_tree_info(struct rn6752 *rn6752)
{
	struct device *dev = &rn6752->client->dev;
	struct device_node *node = dev->of_node;        /* 设备树节点 */
	int ret;
    unsigned int i;
 
	/* 获取设备树中 “rockchip,camera-module-index” 节点的信息，用于摄像头模块索引 */
	ret = of_property_read_u32(node, RKMODULE_CAMERA_MODULE_INDEX,
				   &rn6752->module_index);
	/* 获取设备树中 “rockchip,camera-module-facing” 节点的信息，用于摄像头面向的方向 */
	ret |= of_property_read_string(node, RKMODULE_CAMERA_MODULE_FACING,
				       &rn6752->module_facing);
	/* 获取设备树中 “rockchip,camera-module-name” 节点的信息，用于摄像头的名称 */
	ret |= of_property_read_string(node, RKMODULE_CAMERA_MODULE_NAME,
				       &rn6752->module_name);
	/* 获取设备树中 “rockchip,camera-module-lens-name” 节点的信息，用于摄像头的镜头名称 */
	ret |= of_property_read_string(node, RKMODULE_CAMERA_LENS_NAME,
				       &rn6752->len_name);
	if (ret) {
		dev_err(dev, "could not get module information!\n");
		return -EINVAL;
	}
 
	/* 获取设备 PWDN 和复位的引脚句柄 */
	rn6752->pwdn_gpio = devm_gpiod_get(dev, "pwdn", GPIOD_OUT_LOW);
	if (IS_ERR(rn6752->pwdn_gpio))
        dev_warn(dev, "Failed to get pwdn-gpios, maybe no use\n");
	rn6752->reset_gpio = devm_gpiod_get(dev, "reset", GPIOD_OUT_LOW);
	if (IS_ERR(rn6752->reset_gpio))
        dev_warn(dev, "Failed to get reset-gpios, maybe no use\n");
	
	/* 获取摄像头的时钟资源 */
	rn6752->xvclk = devm_clk_get(dev, "xvclk");
	if (IS_ERR(rn6752->xvclk)) {
		dev_err(dev, "Failed to get xvclk\n");
		return -EINVAL;
	}
 
    for (i = 0; i < RN6752_NUM_SUPPLIES; i++)
		rn6752->supplies[i].supply = rn6752_supply_names[i];
 
    /* 获取摄像头设备的电源管理器句柄 */
	ret = devm_regulator_bulk_get(dev, RN6752_NUM_SUPPLIES, rn6752->supplies);
    if (ret)
    {
        dev_err(dev, "Failed to get power regulators\n");
		return -EINVAL;
    }
    
	return 0;
}
 
/**
 * @brief 初始化 rn6752 摄像头的硬件控制器函数，通过命令
 * “v4l2-ctl -d /dev/v4l-subdev5 --list-ctrls” 可以查看
 * @param rn6752 摄像头结构体指针
*/
static int rn6752_initialize_controls(struct rn6752 *rn6752)
{
	struct v4l2_ctrl_handler *handler;
	int ret;
 
	handler = &rn6752->ctrls;
 
	/* 初始化 rn6752->ctrls，该函数需要两个参数：控制处理器对象和控制器的数量 */
	ret = v4l2_ctrl_handler_init(handler, 3);
	if (ret)
		return ret;
	
	handler->lock = &rn6752->lock;
 
	/* 创建一个 V4L2 控制器对象，并将其与 rn6752->ctrls 关联起来 */
	rn6752->link_frequency = v4l2_ctrl_new_std(handler, &rn6752_ctrl_ops,
					  V4L2_CID_PIXEL_RATE, 0, RN6752_PIXEL_RATE, 1, RN6752_PIXEL_RATE);
 
	/* 创建一个带有选项菜单的 V4L2 控制器对象 */
	v4l2_ctrl_new_int_menu(handler, NULL, V4L2_CID_LINK_FREQ,
				ARRAY_SIZE(link_freq_menu_items) - 1, 0, link_freq_menu_items);
 
	/* 创建另一个带有选项菜单的 V4L2 控制器对象 */
	v4l2_ctrl_new_std_menu_items(handler, &rn6752_ctrl_ops, V4L2_CID_TEST_PATTERN,
					ARRAY_SIZE(rn6752_test_pattern_menu) - 1, 0, 0, rn6752_test_pattern_menu);
	rn6752->subdev.ctrl_handler = &rn6752->ctrls;
 
	if (handler->error) {
		ret = handler->error;
		dev_err(&rn6752->client->dev, "Failed to init controls(%d)\n", ret);
		goto err_free_handler;
	}
 
	return 0;
 
err_free_handler:
	v4l2_ctrl_handler_free(handler);
 
	return ret;
}
 
/**
 * @brief 根据读取到的芯片 ID 和版本号计算出一个 id 值，并与预定义的 RN6752_ID 进行比较
 * @param rn6752 摄像头设备
*/
static int rn6752_check_sersor_id(struct rn6752 *rn6752)
{
	struct i2c_client *client = rn6752->client;
	u8 pid, ver;
	int ret;
 
	dev_dbg(&client->dev, "%s:\n", __func__);
 
	/* Check sensor revision */
	ret = rn6752_read(client, REG_SC_CHIP_ID_H, &pid);          /* 读取芯片 ID 的高字节 */
	if (!ret)
		ret = rn6752_read(client, REG_SC_CHIP_ID_L, &ver);      /* 读取芯片 ID 的低字节 */
 
	if (!ret) {
		unsigned short id;
 
		id = SENSOR_ID(pid, ver);
		if (id != RN6752_ID) {
			ret = -1;
			dev_err(&client->dev, "Sensor detection failed (%04X, %d)\n", id, ret);
		} else {
			dev_info(&client->dev, "Found %04X sensor\n", id);
		}
	}
 
	return ret;
}
 
 
/**
* @brief 系统检测到与该驱动程序匹配的 I2C 设备时
* @param client 指向 I2C 客户端结构体的指针。该结构体包含了有关 I2C 设备的信息，如设备地址、总线信息等
* @param id 指向 I2C 设备 ID 的指针。这个参数用于在多个相同类型的设备中进行区分和匹配
* @return 返回初始化结构
*/
static int rn6752_probe(struct i2c_client *client, const struct i2c_device_id *id)
{
	struct device *dev = &client->dev;
    struct v4l2_subdev *sd;
    struct rn6752 *rn6752;
    char facing[2];
	int ret;
 
	/* 打印驱动的版本信息的函数，其作用相当于 printk() 函数 */
	dev_info(dev, "driver version: %02x.%02x.%02x", DRIVER_VERSION >> 16,
		(DRIVER_VERSION & 0xff00) >> 8,	DRIVER_VERSION & 0x00ff);
 
    /* 为设备分配内存，并将内存与设备进行关联。在驱动程序退出时，内存会自动被释放。被称为“设备内存管理” */
	rn6752 = devm_kzalloc(dev, sizeof(*rn6752), GFP_KERNEL);
	if (!rn6752)
	{
		dev_err(dev, "Memory control request failed\n");
		return -ENOMEM;
	}
 
    rn6752->client = client;
	sd = &rn6752->subdev;
 
    /* 获取设备树信息 */
	ret = rn6752_device_tree_info(rn6752);
	if (ret != 0)
		return -EINVAL;
 
    /* rn6752_mipi_framesizes 是 rn6752 mipi 通信支持的所有帧格式 */
    rn6752->framesize_cfg = rn6752_mipi_framesizes;
	rn6752->cfg_num = ARRAY_SIZE(rn6752_mipi_framesizes);
	/* 获取摄像头传感器支持的图像帧格式 */
	rn6752_get_default_format(rn6752, &rn6752->format);
	rn6752->frame_size = &rn6752->framesize_cfg[0];             /* 设置帧大小 */
	rn6752->format.width = rn6752->framesize_cfg[0].width;      /* 设置宽度 */
	rn6752->format.height = rn6752->framesize_cfg[0].height;    /* 设置高度 */
	rn6752->fps = DIV_ROUND_CLOSEST(rn6752->framesize_cfg[0].max_fps.denominator,
	rn6752->framesize_cfg[0].max_fps.numerator);        		/* 设置最大帧速率 */
 
    mutex_init(&rn6752->lock);
 
#ifdef CONFIG_VIDEO_V4L2_SUBDEV_API
    /* 通过v4l2框架注册一个V4L2子设备，并初始化该子设备的操作函数和内部操作函数指针 */
	v4l2_i2c_subdev_init(sd, client, &rn6752_subdev_ops);
    ret = rn6752_initialize_controls(rn6752);
	if (ret)
	{
		dev_info(dev, "V4l2 control menu initialization failed");
		goto err_destroy_mutex;
	}
 
    /* 关联子设备的内部操作函数，用于打开摄像头操作 */
	sd->internal_ops = &rn6752_subdev_internal_ops;
    sd->flags |= V4L2_SUBDEV_FL_HAS_DEVNODE |           /* 设备有对应的设备节点文件，可以通过该文件进行访问 */
		     V4L2_SUBDEV_FL_HAS_EVENTS;                 /* 设备具有事件机制，可以作为事件源供其他驱动程序使用 */
#endif
 
    /* 打开设备的电源 */
	ret = __rn6752_power_on(rn6752);
	if (ret)
		goto err_free_handler;
 
    /* 通过读取 RN6752 的产品 ID 判断设备是否存在 */
	ret = rn6752_check_sersor_id(rn6752);
	if (ret)
		goto err_power_off;
 
#if defined(CONFIG_MEDIA_CONTROLLER)
    rn6752->pad.flags = MEDIA_PAD_FL_SOURCE;            /* 表明该子设备是媒体管道中的源设备，即数据的起始点 */
	sd->entity.function = MEDIA_ENT_F_CAM_SENSOR;       /* 表示该实体是一个相机传感器 */
	ret = media_entity_pads_init(&sd->entity, 1, &rn6752->pad);     /* 初始化 sd->entity 媒体实体的 pads（端口）属性 */
	if (ret < 0) {
		dev_err(dev, "Media pad port initialization failed\n");
		goto err_power_off;
	}
#endif
 
    /* 根据设备树提供的信息，判断摄像头的方向 */
    memset(facing, 0, sizeof(facing));
	if (strcmp(rn6752->module_facing, "back") == 0)
		facing[0] = 'b';
	else
		facing[0] = 'f';
 
    /* 名称格式如 m00_f_rn6752 1-002c:bus */
	snprintf(sd->name, sizeof(sd->name), "m%02d_%s_%s %s", 
			rn6752->module_index, facing, DRIVER_NAME, dev_name(sd->dev));
	/* 将传感器子设备添加到V4L2异步子系统中，以便能够与其他V4L2组件进行交互。 */
	/* 它会自动设置子设备的相关回调函数，并与异步框架进行适当的关联，以管理传感器的采集和控制操作 */
	ret = v4l2_async_register_subdev_sensor_common(sd);
	if (ret)
	{
		dev_err(dev, "Failed to add sensor to V4L2 asynchronous subsystem\n");
		goto err_clean_entity;
	}
 
    /* 摄像头传感器注册成功，并打印日志信息 */
	dev_info(dev, "%s sensor driver registered !!\n", sd->name);
 
    /* 完成初始化后，使 rn6752 进入睡眠模式 */
	rn6752->power_on = false;
    if (!IS_ERR(rn6752->pwdn_gpio))
				gpiod_set_value_cansleep(rn6752->pwdn_gpio, 1);
 
	return 0;
 
err_clean_entity:
#if defined(CONFIG_MEDIA_CONTROLLER)
	media_entity_cleanup(&sd->entity);
#endif
err_power_off:
	__rn6752_power_off(rn6752);
err_free_handler:
#ifdef CONFIG_VIDEO_V4L2_SUBDEV_API
	v4l2_ctrl_handler_free(&rn6752->ctrls);
#endif
err_destroy_mutex:
	mutex_destroy(&rn6752->lock);
 
 
	return ret;
}
 
/**
* @brief 当设备驱动被删除释放时，执行此函数
* @param client 指向 I2C 客户端结构体的指针。该结构体包含了有关 I2C 设备的信息，如设备地址、总线信息等
* @return 返回操作结果
*/
static int rn6752_remove(struct i2c_client *client)
{
    struct v4l2_subdev *sd = i2c_get_clientdata(client);
	struct rn6752 *rn6752 = to_rn6752(sd);
 
#ifdef CONFIG_VIDEO_V4L2_SUBDEV_API
	/* 释放V4L2控制器处理器所占用的资源 */
	v4l2_ctrl_handler_free(&rn6752->ctrls);
#endif
	/* 注销一个V4L2子设备 */
	v4l2_async_unregister_subdev(sd);
#if defined(CONFIG_MEDIA_CONTROLLER)
	media_entity_cleanup(&sd->entity);
#endif
	mutex_destroy(&rn6752->lock);
 
	__rn6752_power_off(rn6752);
	return 0;
}
 
/* 设备树节点匹配表格，与设备树中的节点描述信息一样时，匹配成功 */
#if IS_ENABLED(CONFIG_OF)
static const struct of_device_id rn6752_of_match[] = {
	{ .compatible = "richnex,rn6752v1" },
	{ /* sentinel */ },
};
MODULE_DEVICE_TABLE(of, rn6752_of_match);
#endif
 
/* 设备 ID 表格，与设备名称一样时匹配成功，主要用于低版本linux内核的匹配方式 */
static const struct i2c_device_id rn6752_match_id[] = {
	{ "richnex,rn6752v1", 0 },
	{ /* sentinel */ },
};
 
/* 描述和注册一个 I2C 设备驱动程序 */
static struct i2c_driver rn6752_i2c_driver = {
	.driver = {                                             /* 驱动程序信息的子结构体 */
		.name	= DRIVER_NAME,                              /* 设置驱动程序的名称 */
		.of_match_table = of_match_ptr(rn6752_of_match),    /* 用于匹配设备树节点的表格 */
	},
	.probe		= rn6752_probe,                 /* I2C 设备被检测到时进行设备初始化和处理 */
	.remove		= rn6752_remove,                /* I2C 设备从系统中移除时进行清理和资源释放 */
	.id_table	= rn6752_match_id,              /* I2C 设备 ID 表格，平台设备匹配方式之一，用设备和驱动的名称进行匹配 */
};
 
static int __init sensor_mod_init(void)
{
	/* 注册 I2C 驱动程序 */
	return i2c_add_driver(&rn6752_i2c_driver);
}
 
static void __exit sensor_mod_exit(void)
{
	/* 注销 I2C 驱动程序 */
	i2c_del_driver(&rn6752_i2c_driver);
}
 
device_initcall_sync(sensor_mod_init);      /* 注册一个设备初始化函数 */
module_exit(sensor_mod_exit);               /* 注销一个设备初始化函数 */
 
MODULE_AUTHOR("jiaozhu <cn_jiaozhu@qq.com>");
MODULE_DESCRIPTION("RN6752 CMOS Image Sensor driver");

参考资料

  1. MIPI扫盲——D-PHY介绍：https://zhuanlan.zhihu.com/p/638769112?utm_id=0
posted @   浇筑菜鸟  阅读(6707)  评论(2)  编辑  收藏  举报
相关博文：
· Linux RN6752 驱动编写
· Linux MIPI 调试中常见的问题
· 瑞芯微平台MIPI摄像头应用程序编写
· Camera | 5.Linux v4l2架构(基于rk3568)
· Camera | 4.瑞芯微平台MIPI摄像头应用程序编写
阅读排行：
· DeepSeek 开源周回顾「GitHub 热点速览」
· 物流快递公司核心技术能力-地址解析分单基础技术分享
· .NET 10首个预览版发布：重大改进与新特性概览！
· AI与.NET技术实操系列（二）：开始使用ML.NET
· 单线程的Redis速度为什么快？
点击右上角即可分享
微信分享提示
AI FOR CODE 大赛