rk3588 camera bringup记录

已于 2024-01-25 19:10:55 修改
阅读量2.1k 收藏 19
点赞数 4
分类专栏： Linux driver 资料 文章标签： linux arm 驱动开发
于 2022-09-27 15:05:58 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/MATLABCSD/article/details/127067138
版权
本文详细记录了在rk3588平台上进行摄像头驱动bringup的过程，包括准备工作、代码修改、调试步骤，涉及dts配置、i2c通信、CIF绑定、AF调试等关键环节，最终实现摄像头的正常预览和拍照功能。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

最近几天在rk3588平台上调试点亮camera，记录下调试过程

1. 准备工作

首先获取相关camera ov13855的模组打样规格书，ov13855 datasheet，板子硬件原理图以及对应的layout，检查pin脚定义、pin脚顺序，确定电源IOVDD、DVDD、AVDD以及AF电源，确定几路mipi，确定相关AF型号、AF i2c地址以及获取相关IC datasheet，如果有需要，还要确定模组成像方向

另外可能需要确定焦距、光圈、视场角、景深，如果AF支持pdaf，还需要获取shield pixel的坐标点，这都是后话，看具体需求

2. bringup 工作

2.1 代码准备工作

原则上应该是bringup前找camera原厂获取camera的initial，preview，video、capture等场景下的寄存器配置，如下信息需要check
在这里插入图片描述
上面的要求是之前展讯平台内部确认camera的表单，如果是在方案公司，这些就不是那么重要了，许多确认步骤都不会进行，比如DVT测试。

我们进入正题，在rockchip 3588上bringup，这里我们使用的是默认的驱动参数，tuning参数也是默认的，rk3588平台驱动是使用的时v4l2+ media entity架构，我们只需要注册ov13855 subdev，像mipi phy、csi 、isp等节点只需要打开相应的dts节点，平台已经注册好，不需要做过多的改动

2.2 camera bringup debug过程

2.2.1 dts配置及驱动代码修改

dts设置可参考平台已有的，如下时我配置的


// SPDX-License-Identifier: (GPL-2.0+ OR MIT)
/*
 * Copyright (c) 2022 Rockchip Electronics Co., Ltd.
 *
 */

/ {
	cam_ircut0: cam_ircut {
		status = "okay";
		compatible = "rockchip,ircut";
		ircut-open-gpios = <&gpio4 RK_PA0 GPIO_ACTIVE_HIGH>;
		ircut-close-gpios  = <&gpio4 RK_PA1 GPIO_ACTIVE_HIGH>;
		rockchip,camera-module-index = <0>;
		rockchip,camera-module-facing = "back";
	};

};

&csi2_dcphy0 {
	status = "okay";

	ports {
		#address-cells = <1>;
		#size-cells = <0>;
		port@0 {
			reg = <0>;
			#address-cells = <1>;
			#size-cells = <0>;

			mipidphy0_in_ucam0: endpoint@1 {
				reg = <1>;
				remote-endpoint = <&ov13855_out0>;
				data-lanes = <1 2 3 4>;
			};
		};
		port@1 {
			reg = <1>;
			#address-cells = <1>;
			#size-cells = <0>;

			csidcphy0_out: endpoint@0 {
				reg = <0>;
				remote-endpoint = <&mipi0_csi2_input>;
			};
		};
	};
};

&csi2_dphy0_hw {
	status = "okay";
};

&i2c4 {
	status = "okay";
	pinctrl-0 = <&i2c4m0_xfer>;
	
	dw9763: dw9763@c {
		compatible = "dongwoon,dw9763";
		status = "okay";
		reg = <0xc>;
		rockchip,camera-module-index = <0>;
		rockchip,vcm-start-current = <10>;
		rockchip,vcm-rated-current = <85>;
		//rockchip,vcm-step-mode = <5>;
		rockchip,camera-module-facing = "back";
		vdd-gpio = <&aw_gpio1 0 GPIO_ACTIVE_HIGH>;
		};


	ov13855: ov13855@10 {
		compatible = "ovti,ov13855";
		status = "okay";
		reg = <0x10>;
		clocks = <&cru CLK_MIPI_CAMARAOUT_M1>;
		clock-names = "xvclk";
		pinctrl-names = "default";
		pinctrl-0 = <&mipim0_camera1_clk>;
		power-domains = <&power RK3588_PD_VI>;
		reset-gpios = <&gpio1 RK_PB0 GPIO_ACTIVE_HIGH>;
		pwdn-gpios = <&gpio1 RK_PA4 GPIO_ACTIVE_HIGH>;
		//lf-gpios = <&aw_gpio1 0 GPIO_ACTIVE_HIGH>;
		//iovdd-gpios = <&aw_gpio1 1 GPIO_ACTIVE_HIGH>;
		vaf-gpios = <&aw_gpio1 2 GPIO_ACTIVE_HIGH>;
		avdd-gpios = <&aw_gpio1 3 GPIO_ACTIVE_HIGH>;
		dvdd-gpios = <&aw_gpio1 4 GPIO_ACTIVE_HIGH>;
		rockchip,camera-module-index = <0>;
		rockchip,camera-module-facing = "back";
		rockchip,camera-module-name = "CMK-OT2016-FV1";
		rockchip,camera-module-lens-name = "default";
		lens-focus = <&dw9763>;
		port {
			ov13855_out0: endpoint {
				remote-endpoint = <&mipidphy0_in_ucam0>;
				data-lanes = <1 2 3 4>;
			};
		};
	};
};

&mipi0_csi2 {
	status = "okay";

	ports {
		#address-cells = <1>;
		#size-cells = <0>;

		port@0 {
			reg = <0>;
			#address-cells = <1>;
			#size-cells = <0>;

			mipi0_csi2_input: endpoint@1 {
				reg = <1>;
				remote-endpoint = <&csidcphy0_out>;
			};
		};

		port@1 {
			reg = <1>;
			#address-cells = <1>;
			#size-cells = <0>;

			mipi0_csi2_output: endpoint@0 {
				reg = <0>;
				remote-endpoint = <&cif_mipi_in0>;
			};
		};
	};
};

&pinctrl {
	cam {
	/*
		mipidphy0_pwr: mipidphy0-pwr {
			rockchip,pins =
				<1 RK_PB2 RK_FUNC_GPIO &pcfg_pull_none>;
		};
	*/
	};
};

&rkcif {
	status = "okay";
};

&rkcif_mipi_lvds {
	status = "okay";

	port {
		cif_mipi_in0: endpoint {
			remote-endpoint = <&mipi0_csi2_output>;
		};
	};
};

&rkcif_mipi_lvds_sditf {
	status = "okay";

	port {
		mipi_lvds_sditf: endpoint {
			remote-endpoint = <&isp0_vir0>;
		};
	};
};

&rkcif_mmu {
	status = "okay";
};

&rkisp0 {
	status = "okay";
};

&isp0_mmu {
	status = "okay";
};

&rkisp0_vir0 {
	status = "okay";

	port {
		#address-cells = <1>;
		#size-cells = <0>;

		isp0_vir0: endpoint@0 {
			reg = <0>;
			remote-endpoint = <&mipi_lvds_sditf>;
		};
	};
};

这里我使用的如下的通路，
在这里插入图片描述
后摄配置为第一条通路，前摄配置为第二条通路

如此配置dts，修改ov13855.c中注册时的上电方式，按照datasheet中power on sequence和power down sequence配置上下电时序

注意上下电时序一定要符合datasheet，同时注意reset和powerdown两个引脚的有效电平和时序

2.2.2 调试过程1

这一步主要是确定sensor i2c是否通信正常，CIF和sensor是否已经绑定

在开机过程中会进行ov13855 chip id的读取，以及subdev的注册

2.2.2.1 i2c通讯

不了解i2c协议的去看《i2c总线协议.pdf》，这里不再赘述
log中出现i2c读取错误的或者读取到全是0的（可能powerdown或reset的原因）需要量以下信号，Power（包括AVDD/DVDD/IOVDD）/PowerDown/Reset/Mclk/I2c clk和data

此处camera i2c不通的可能原因（这里是i2c host正常的前提下）：

  1. camera power 和datasheet 的供电要求不一致
  2. PowerDown电平与有效电平不一致，另外也可能PowerDown电平和实际配置的GPIO输出电压不一致，可以查看对应GPIO是否别其他模块占用，是否设置为GPIO模式，检查硬件电路是否有电阻虚焊或漏焊
  3. RESET 同 上面的PowerDown
  4. Mclk异常，正常参考频率为24M，可能引脚复用没有配置正确，可通过cat /sys/kernel/debug/pinctrl/pinctrl/pinmux-pins 查看，IO电源域未供电，IO电源域与软件IO-domain不匹配
  5. ov13855节点是否配置正确，i2c地址是否正确，检查i2c供电是否正常，在无信号的情况下是否处于高电平，i2c 波形是否正常

我这边遇到的问题是i2c gpio被其他器件占用，导致注册时报错，板卡上摄像头公座 贴反导致i2c 读出值为0

2.2.2.2 CIF和sensor绑定

这块涉及到V4L2架构，具体的v4l2架构的注册和 media entity可参考如下文章：

  1. v4l2 video 实例分析
  2. Linux V4L2驱动框架分析
  3. V4L2 框架media

如何判断 camera 驱动是否加载成功
当所有的 camera 都注册完毕， kernel 会打印出如下的 log。
localhost ~ # dmesg | grep Async
[ 0.682982] rkisp: Async subdev notifier completed
如发现 kernel 没有 Async subdev notifier completed 这行 log，那么请首先查看 sensor是否有相关的报错， I2C 通讯是否成功。

RKISP 驱动如果加载成功，会有 video 及 media 设备存在于/dev/目录下。系统中可能存在
多个/dev/video 设备，通过/sys 可以查询到 RKISP 注册的 video 节点


rk3588_s:/ # grep -H '' /sys/class/video4linux/video*/name
/sys/class/video4linux/video0/name:stream_cif_mipi_id0
/sys/class/video4linux/video1/name:stream_cif_mipi_id1
/sys/class/video4linux/video10/name:rkcif_tools_id2
/sys/class/video4linux/video11/name:stream_cif_mipi_id0
/sys/class/video4linux/video12/name:stream_cif_mipi_id1
/sys/class/video4linux/video13/name:stream_cif_mipi_id2
/sys/class/video4linux/video14/name:stream_cif_mipi_id3
/sys/class/video4linux/video15/name:rkcif_scale_ch0
/sys/class/video4linux/video16/name:rkcif_scale_ch1
/sys/class/video4linux/video17/name:rkcif_scale_ch2
/sys/class/video4linux/video18/name:rkcif_scale_ch3
/sys/class/video4linux/video19/name:rkcif_tools_id0
/sys/class/video4linux/video2/name:stream_cif_mipi_id2
/sys/class/video4linux/video20/name:rkcif_tools_id1
/sys/class/video4linux/video21/name:rkcif_tools_id2
/sys/class/video4linux/video22/name:rkisp_mainpath
/sys/class/video4linux/video23/name:rkisp_selfpath
/sys/class/video4linux/video24/name:rkisp_fbcpath
/sys/class/video4linux/video25/name:rkisp_iqtool
/sys/class/video4linux/video26/name:rkisp_rawrd0_m
/sys/class/video4linux/video27/name:rkisp_rawrd2_s
/sys/class/video4linux/video28/name:rkisp_rawrd1_l
/sys/class/video4linux/video29/name:rkisp-statistics
/sys/class/video4linux/video3/name:stream_cif_mipi_id3
/sys/class/video4linux/video30/name:rkisp-input-params
/sys/class/video4linux/video31/name:rkisp_mainpath
/sys/class/video4linux/video32/name:rkisp_selfpath
/sys/class/video4linux/video33/name:rkisp_fbcpath
/sys/class/video4linux/video34/name:rkisp_iqtool
/sys/class/video4linux/video35/name:rkisp_rawrd0_m
/sys/class/video4linux/video36/name:rkisp_rawrd2_s
/sys/class/video4linux/video37/name:rkisp_rawrd1_l
/sys/class/video4linux/video38/name:rkisp-statistics
/sys/class/video4linux/video39/name:rkisp-input-params
/sys/class/video4linux/video4/name:rkcif_scale_ch0
/sys/class/video4linux/video40/name:stream_hdmirx
/sys/class/video4linux/video5/name:rkcif_scale_ch1
/sys/class/video4linux/video6/name:rkcif_scale_ch2
/sys/class/video4linux/video7/name:rkcif_scale_ch3
/sys/class/video4linux/video8/name:rkcif_tools_id0
/sys/class/video4linux/video9/name:rkcif_tools_id1

2.2.2 调试过程2

rk3588有两个csi_dcphy，两个csi_dphy，我第一次配置的时使用csi_dphy0,但调试到后面v4l2-ctl不能抓取数据，后面换成csi_dcphy0才正常抓图，具体的过程如下

  1. 检查确定CONFIG_VIDEO_ROCKCHIP_CIF必须要配置
  2. 检查meida拓扑 
     
 /dev/media0 拓扑如下
 
 media-ctl -p
 Opening media device /dev/media0
 Enumerating entities
 Found 11 entities
 Enumerating pads and links
 Media controller API version 0.0.66
 
 Media device information
 ------------------------
 driver rkcif
 model rkcif-mipi-lvds2
 serial
 bus info
 hw revision 0x0
 driver version 0.0.66
 
 Device topology
 - entity 1: stream_cif_mipi_id0 (1 pad, 8 links)
 type Node subtype V4L
 device node name /dev/video0
 pad0: Sink
 <- "rockchip-mipi-csi2":1 [ENABLED]
 <- "rockchip-mipi-csi2":2 []
 <- "rockchip-mipi-csi2":3 []
 <- "rockchip-mipi-csi2":4 []
 <- "rockchip-mipi-csi2":5 []
 <- "rockchip-mipi-csi2":6 []
 <- "rockchip-mipi-csi2":7 []
 <- "rockchip-mipi-csi2":8 []
 
 - entity 5: stream_cif_mipi_id1 (1 pad, 8 links)
 type Node subtype V4L
 device node name /dev/video1
 pad0: Sink
 <- "rockchip-mipi-csi2":1 []
 <- "rockchip-mipi-csi2":2 [ENABLED]
 <- "rockchip-mipi-csi2":3 []
 <- "rockchip-mipi-csi2":4 []
 <- "rockchip-mipi-csi2":5 []
 <- "rockchip-mipi-csi2":6 []
 <- "rockchip-mipi-csi2":7 []
 <- "rockchip-mipi-csi2":8 []
 
 - entity 9: stream_cif_mipi_id2 (1 pad, 8 links)
 type Node subtype V4L
 device node name /dev/video2
 pad0: Sink
 <- "rockchip-mipi-csi2":1 []
 <- "rockchip-mipi-csi2":2 []
 <- "rockchip-mipi-csi2":3 [ENABLED]
 <- "rockchip-mipi-csi2":4 []
 <- "rockchip-mipi-csi2":5 []
 <- "rockchip-mipi-csi2":6 []
 <- "rockchip-mipi-csi2":7 []
 <- "rockchip-mipi-csi2":8 []
 
 - entity 13: stream_cif_mipi_id3 (1 pad, 8 links)
 type Node subtype V4L
 device node name /dev/video3
 pad0: Sink
 <- "rockchip-mipi-csi2":1 []
 <- "rockchip-mipi-csi2":2 []
 <- "rockchip-mipi-csi2":3 []
 <- "rockchip-mipi-csi2":4 [ENABLED]
 <- "rockchip-mipi-csi2":5 []
 <- "rockchip-mipi-csi2":6 []
 <- "rockchip-mipi-csi2":7 []
 <- "rockchip-mipi-csi2":8 []
 
 - entity 17: rkcif_scale_ch0 (1 pad, 8 links)
 type Node subtype V4L
 device node name /dev/video4
 pad0: Sink
 <- "rockchip-mipi-csi2":1 []
 <- "rockchip-mipi-csi2":2 []
 <- "rockchip-mipi-csi2":3 []
 <- "rockchip-mipi-csi2":4 []
 <- "rockchip-mipi-csi2":5 [ENABLED]
 <- "rockchip-mipi-csi2":6 []
 <- "rockchip-mipi-csi2":7 []
 <- "rockchip-mipi-csi2":8 []
 
 - entity 21: rkcif_scale_ch1 (1 pad, 8 links)
 type Node subtype V4L
 device node name /dev/video5
 pad0: Sink
 <- "rockchip-mipi-csi2":1 []
 <- "rockchip-mipi-csi2":2 []
 <- "rockchip-mipi-csi2":3 []
 <- "rockchip-mipi-csi2":4 []
 <- "rockchip-mipi-csi2":5 []
 <- "rockchip-mipi-csi2":6 [ENABLED]
 <- "rockchip-mipi-csi2":7 []
 <- "rockchip-mipi-csi2":8 []
 
 - entity 25: rkcif_scale_ch2 (1 pad, 8 links)
 type Node subtype V4L
 device node name /dev/video6
 pad0: Sink
 <- "rockchip-mipi-csi2":1 []
 <- "rockchip-mipi-csi2":2 []
 <- "rockchip-mipi-csi2":3 []
 <- "rockchip-mipi-csi2":4 []
 <- "rockchip-mipi-csi2":5 []
 <- "rockchip-mipi-csi2":6 []
 <- "rockchip-mipi-csi2":7 [ENABLED]
 <- "rockchip-mipi-csi2":8 []
 
 - entity 29: rkcif_scale_ch3 (1 pad, 8 links)
 type Node subtype V4L
 device node name /dev/video7
 pad0: Sink
 <- "rockchip-mipi-csi2":1 []
 <- "rockchip-mipi-csi2":2 []
 <- "rockchip-mipi-csi2":3 []
 <- "rockchip-mipi-csi2":4 []
 <- "rockchip-mipi-csi2":5 []
 <- "rockchip-mipi-csi2":6 []
 <- "rockchip-mipi-csi2":7 []
 <- "rockchip-mipi-csi2":8 [ENABLED]
 
 - entity 33: rockchip-mipi-csi2 (9 pads, 65 links)
 type V4L2 subdev subtype Unknown
 device node name /dev/v4l-subdev0
 pad0: Sink
 [fmt:SBGGR10/4224x3136
 crop.bounds:(0,0)/4224x3136
 crop:(0,0)/4224x3136]
 <- "rockchip-csi2-dphy0":1 [ENABLED]
 pad1: Source
 -> "stream_cif_mipi_id0":0 [ENABLED]
 -> "stream_cif_mipi_id1":0 []
 -> "stream_cif_mipi_id2":0 []
 -> "stream_cif_mipi_id3":0 []
 -> "rkcif_scale_ch0":0 []
 -> "rkcif_scale_ch1":0 []
 -> "rkcif_scale_ch2":0 []
 -> "rkcif_scale_ch3":0 []
 pad2: Source
 -> "stream_cif_mipi_id0":0 []
 -> "stream_cif_mipi_id1":0 [ENABLED]
 -> "stream_cif_mipi_id2":0 []
 -> "stream_cif_mipi_id3":0 []
 -> "rkcif_scale_ch0":0 []
 -> "rkcif_scale_ch1":0 []
 -> "rkcif_scale_ch2":0 []
 -> "rkcif_scale_ch3":0 []
 pad3: Source
 -> "stream_cif_mipi_id0":0 []
 -> "stream_cif_mipi_id1":0 []
 -> "stream_cif_mipi_id2":0 [ENABLED]
 -> "stream_cif_mipi_id3":0 []
 -> "rkcif_scale_ch0":0 []
 -> "rkcif_scale_ch1":0 []
 -> "rkcif_scale_ch2":0 []
 -> "rkcif_scale_ch3":0 []
 pad4: Source
 -> "stream_cif_mipi_id0":0 []
 -> "stream_cif_mipi_id1":0 []
 -> "stream_cif_mipi_id2":0 []
 -> "stream_cif_mipi_id3":0 [ENABLED]
 -> "rkcif_scale_ch0":0 []
 -> "rkcif_scale_ch1":0 []
 -> "rkcif_scale_ch2":0 []
 -> "rkcif_scale_ch3":0 []
 pad5: Source
 -> "stream_cif_mipi_id0":0 []
 -> "stream_cif_mipi_id1":0 []
 -> "stream_cif_mipi_id2":0 []
 -> "stream_cif_mipi_id3":0 []
 -> "rkcif_scale_ch0":0 [ENABLED]
 -> "rkcif_scale_ch1":0 []
 -> "rkcif_scale_ch2":0 []
 -> "rkcif_scale_ch3":0 []
 pad6: Source
 -> "stream_cif_mipi_id0":0 []
 -> "stream_cif_mipi_id1":0 []
 -> "stream_cif_mipi_id2":0 []
 -> "stream_cif_mipi_id3":0 []
 -> "rkcif_scale_ch0":0 []
 -> "rkcif_scale_ch1":0 [ENABLED]
 -> "rkcif_scale_ch2":0 []
 -> "rkcif_scale_ch3":0 []
 pad7: Source
 -> "stream_cif_mipi_id0":0 []
 -> "stream_cif_mipi_id1":0 []
 -> "stream_cif_mipi_id2":0 []
 -> "stream_cif_mipi_id3":0 []
 -> "rkcif_scale_ch0":0 []
 -> "rkcif_scale_ch1":0 []
 -> "rkcif_scale_ch2":0 [ENABLED]
 -> "rkcif_scale_ch3":0 []
 pad8: Source
 -> "stream_cif_mipi_id0":0 []
 -> "stream_cif_mipi_id1":0 []
 -> "stream_cif_mipi_id2":0 []
 -> "stream_cif_mipi_id3":0 []
 -> "rkcif_scale_ch0":0 []
 -> "rkcif_scale_ch1":0 []
 -> "rkcif_scale_ch2":0 []
 -> "rkcif_scale_ch3":0 [ENABLED]
 
 - entity 43: rockchip-csi2-dphy0 (2 pads, 2 links)
 type V4L2 subdev subtype Unknown
 device node name /dev/v4l-subdev1
 pad0: Sink
 [fmt:SBGGR10/4224x3136
 crop.bounds:(0,0)/4224x3136]
 <- "m00_b_ov13855 4-0010":0 [ENABLED]
 pad1: Source
 -> "rockchip-mipi-csi2":0 [ENABLED]
 
 - entity 48: m00_b_ov13855 4-0010 (1 pad, 1 link)
 type V4L2 subdev subtype Sensor
 device node name /dev/v4l-subdev2
 pad0: Source
 [fmt:SBGGR10/4224x3136
 crop.bounds:(0,0)/4224x3136]
 -> "rockchip-csi2-dphy0":0 [ENABLED]
 
 /dev/media1 拓扑如下
 
 media-ctl -p -d /dev/media1
 Opening media device /dev/media1
 Enumerating entities
 Found 11 entities
 Enumerating pads and links
 Media controller API version 0.0.66
 
 Media device information
 ------------------------
 driver rkisp0-vir0
 model rkisp0
 serial
 bus info
 hw revision 0x0
 driver version 0.0.66
 
 Device topology
 - entity 1: rkisp-isp-subdev (4 pads, 10 links)
 type V4L2 subdev subtype Unknown
 device node name /dev/v4l-subdev3
 pad0: Sink
 [fmt:SBGGR10/4224x3136
 crop.bounds:(0,0)/4224x3136
 crop:(0,0)/4224x3136]
 <- "rkisp_rawrd0_m":0 []
 <- "rkisp_rawrd2_s":0 []
 <- "rkisp_rawrd1_l":0 []
 <- "rkcif-mipi-lvds2":0 [ENABLED]
 pad1: Sink
 <- "rkisp-input-params":0 [ENABLED]
 pad2: Source
 [fmt:YUYV2X8/4224x3136
 crop.bounds:(0,0)/4224x3136
 crop:(0,0)/4224x3136]
 -> "rkisp_mainpath":0 [ENABLED]
 -> "rkisp_selfpath":0 [ENABLED]
 -> "rkisp_fbcpath":0 [ENABLED]
 -> "rkisp_iqtool":0 [ENABLED]
 pad3: Source
 -> "rkisp-statistics":0 [ENABLED]
 
 - entity 6: rkisp_mainpath (1 pad, 1 link)
 type Node subtype V4L
 device node name /dev/video8
 pad0: Sink
 <- "rkisp-isp-subdev":2 [ENABLED]
 
 - entity 12: rkisp_selfpath (1 pad, 1 link)
 type Node subtype V4L
 device node name /dev/video9
 pad0: Sink
 <- "rkisp-isp-subdev":2 [ENABLED]
 
 - entity 18: rkisp_fbcpath (1 pad, 1 link)
 type Node subtype V4L
 device node name /dev/video10
 pad0: Sink
 <- "rkisp-isp-subdev":2 [ENABLED]
 
 - entity 24: rkisp_iqtool (1 pad, 1 link)
 type Node subtype V4L
 device node name /dev/video11
 pad0: Sink
 <- "rkisp-isp-subdev":2 [ENABLED]
 
 - entity 30: rkisp_rawrd0_m (1 pad, 1 link)
 type Node subtype V4L
 device node name /dev/video12
 pad0: Source
 -> "rkisp-isp-subdev":0 []
 
 - entity 36: rkisp_rawrd2_s (1 pad, 1 link)
 type Node subtype V4L
 device node name /dev/video13
 pad0: Source
 -> "rkisp-isp-subdev":0 []
 
 - entity 42: rkisp_rawrd1_l (1 pad, 1 link)
 type Node subtype V4L
 device node name /dev/video14
 pad0: Source
 -> "rkisp-isp-subdev":0 []
 
 - entity 48: rkisp-statistics (1 pad, 1 link)
 type Node subtype V4L
 device node name /dev/video15
 pad0: Sink
 <- "rkisp-isp-subdev":3 [ENABLED]
 
 - entity 54: rkisp-input-params (1 pad, 1 link)
 type Node subtype V4L
 device node name /dev/video16
 pad0: Source
 -> "rkisp-isp-subdev":1 [ENABLED]
 
 - entity 60: rkcif-mipi-lvds2 (1 pad, 1 link)
 type V4L2 subdev subtype Unknown
 device node name /dev/v4l-subdev4
 pad0: Source
 [fmt:SBGGR10/4224x3136]
 -> "rkisp-isp-subdev":0 [ENABLED]

可以看到media拓扑通路正常，v4l2-ctl抓图
v4l2-ctl -d /dev/video0 --set-fmt-video=width=4224,height=3136,pixelformat=BG10 --stream-mmap=3 --stream-skip=10 --stream-to=/data/cif.out
v4l2-ctl -d /dev/video8 --set-fmt-video=width=4224,height=3136,pixelformat=NV12 --stream-mmap=3 --stream-skip=3 --stream-to=/data/cif2.out --stream-count=10 --stream-poll

  1. 如果还抓图失败，则运行这条v4l2指令，然后示波器测量下mipi信号（mipi clk_p clk_n以及几个data脚）

data有数据，具体的帧率可以看到为30fps，帧间隔时间为33.4ms
在这里插入图片描述

一帧数据如下图，分辨率为4224*3136，33.4ms/3136 大致在10微妙左右
在这里插入图片描述

clock 如下
在这里插入图片描述
clk放大后的频率
在这里插入图片描述
通过测量camera端的mipi型号，确定信号都正常，查看media，确定配置正确，但还是抓不到图，在rk redmine上FAE建议换dcphy0测试，如此在dcphy0上可以正常抓图，dphy0上可能某些时序配置可能不够完善，后面有需求再进行debug

以上camera ov13855驱动层已经通了

2.2.3 调试过程3

驱动层通了，之后我们通过Android界面的camera app打开camera，发现不能打开，查看hal层log可以了解到，getcamerainfo函数get到的camera为0，而get的过程中时解析camera3_profiles.xml,修改xml文件，添加ov13855,设置为后摄 cameraId=“0”，lens.facing value=“BACK”

2.2.3.1 camera3_profiles.xml && iqfiles
  1. 将需要更新的库或者 xm 配置文件 push 到板子相应的目录。
    $ adb root && adb remount
    $ adb push <hal3_camera>/etc/camera /vendor/etc/ (android version >= 8.0)
    $ adb push <hal3_camera>/etc/camera /system/etc/ (android version < 8.0)
  2. 重新启动 camera 服务进程
    $ adb shell pkill camera && adb shell pkilll provider
  3. 通过如下命令查看 camera 是否加载成功。
    $ adb shell dumpsys media.camera
  4. 如果没有打印出 camera 相关信息(camera 正常信息有好几百行)，则加载失败。
    此时：
  5. 再次确认配置文件是否有 Push 到板子（普遍是这个问题，请再三确认）：
    $ adb shell
    $ cat /vendor/camera/camera3_profiles.xml //查看该文件是否是修改过后的文件，$ adb logcat|grep “E RkCamera” 查看是否是致命错误，定位分析。
  6. 如果前三步都没有问题，底层驱动正常，可用 v4l2-ctl 抓到数据，此时 camera 应该可以打开了。
    Camera 如果打不开， 可以打开相关 camera log 的开关来定位问题。
    $ adb shell setprop persist.vendor.camera.hal.debug 5

进行到目前，我们camera app还是不能打开，发现时效果参数iqfiles文件不能找到，对比了之前的命名规则为 sensor名+module名+lens name
与dts中的设置对应
rockchip,camera-module-name = “CMK-OT2016-FV1”;
rockchip,camera-module-lens-name = “default”;
所以暂时设置iqfiles为ov13855_CMK-OT2016-FV1_default.json

设置完成后camera app依旧不能打开，log显示在dqbuffer时出现kernel panic，由于rockchip 3588没有sysdump文件也没有log子系统（反正我是没找到），所以kernel panic问题拖了很久，在FAE的建议下升级SDK到ANDROID12_RKR10后问题解决，对比两个SDK版本的iqfiles，一模一样，只能是isp代码更新解决了问题

自此camera app可以预览了

2.3 AF 调试

打开camera app后预览拍照正常，af无法对焦，AF IC为DW9763，平台没有兼容代码，仿照dw9800改写出了dw9763代码，如下

// SPDX-License-Identifier: GPL-2.0
/*
 * dw9763 vcm driver
 *
 * Copyright (C) 2022 Rockchip Electronics Co., Ltd.
 */
//#define DEBUG
#include <linux/delay.h>
#include <linux/i2c.h>
#include <linux/module.h>
#include <linux/pm_runtime.h>
#include <linux/rk-camera-module.h>
#include <linux/version.h>
#include <media/v4l2-ctrls.h>
#include <media/v4l2-device.h>
#include <linux/rk_vcm_head.h>
#include <linux/compat.h>
#include <linux/proc_fs.h>
#include <linux/of.h>
#include <linux/of_irq.h>
#include <linux/of_gpio.h>

#define DRIVER_VERSION			KERNEL_VERSION(0, 0x01, 0x0)
#define DW9763_NAME			"dw9763"

#define DW9763_MAX_CURRENT		100U
#define DW9763_MAX_REG			1023U

#define DW9763_DEFAULT_START_CURRENT	0
#define DW9763_DEFAULT_RATED_CURRENT	100
#define DW9763_DEFAULT_STEP_MODE	0x0
#define DW9763_DEFAULT_T_SACT		0x10
#define DW9763_DEFAULT_T_DIV		0x1
#define REG_NULL			0xFF

#define DW9763_CHIP_ID			0xF9
#define DW9763_REG_CHIP_ID		0x00

static struct i2c_client *dw9763_client;
extern int aw9523_port_set(unsigned int offset);

enum mode_e {
	SAC1_MODE,
	SAC2_MODE,
	SAC2_5_MODE,
	SAC3_MODE,
	SAC4_MODE,
	DIRECT_MODE,
};

/* dw9763 device structure */
struct dw9763_device {
	struct v4l2_ctrl_handler ctrls_vcm;
	struct i2c_client *client;
	struct v4l2_subdev sd;
	struct v4l2_device vdev;
	u16 current_val;

	struct gpio_desc *power_gpio;
	u16 vcc_gpio;
	unsigned short current_related_pos;
	unsigned short current_lens_pos;
	unsigned int start_current;
	unsigned int rated_current;
	unsigned int step;
	unsigned int step_mode;
	unsigned int vcm_movefull_t;
	unsigned int t_src;
	unsigned int t_div;

	struct __kernel_old_timeval start_move_tv;
	struct __kernel_old_timeval end_move_tv;
	unsigned long move_us;

	u32 module_index;
	const char *module_facing;
	struct rk_cam_vcm_cfg vcm_cfg;
	int max_ma;
	struct mutex lock;
};

static inline struct dw9763_device *to_dw9763_vcm(struct v4l2_ctrl *ctrl)
{
	return container_of(ctrl->handler, struct dw9763_device, ctrls_vcm);
}

static inline struct dw9763_device *sd_to_dw9763_vcm(struct v4l2_subdev *subdev)
{
	return container_of(subdev, struct dw9763_device, sd);
}

static int dw9763_write_reg(struct i2c_client *client, u8 reg,
			    u32 len, u32 val)
{
	u32 buf_i, val_i;
	u8 buf[5];
	u8 *val_p;
	__be32 val_be;

	if (len > 4)
		return -EINVAL;

	buf[0] = reg;

	val_be = cpu_to_be32(val);
	val_p = (u8 *)&val_be;
	buf_i = 1;
	val_i = 4 - len;

	while (val_i < 4)
		buf[buf_i++] = val_p[val_i++];

	if (i2c_master_send(client, buf, len + 1) != len + 1) {
		dev_err(&client->dev, "Failed to write 0x%04x,0x%x\n", reg, val);
		return -EIO;
	}
	return 0;
}

static int dw9763_read_reg(struct i2c_client *client,
			    u8 reg,
			    unsigned int len,
			    u32 *val)
{
	struct i2c_msg msgs[2];
	u8 *data_be_p;
	__be32 data_be = 0;
	int ret;

	if (len > 4 || !len)
		return -EINVAL;

	data_be_p = (u8 *)&data_be;
	/* Write register address */
	msgs[0].addr = client->addr;
	msgs[0].flags = 0;
	msgs[0].len = 1;
	msgs[0].buf = (u8 *)&reg;

	/* Read data from register */
	msgs[1].addr = client->addr;
	msgs[1].flags = I2C_M_RD;
	msgs[1].len = len;
	msgs[1].buf = &data_be_p[4 - len];

	ret = i2c_transfer(client->adapter, msgs, ARRAY_SIZE(msgs));
	if (ret != ARRAY_SIZE(msgs))
		return -EIO;

	*val = be32_to_cpu(data_be);

	return 0;
}

static unsigned int dw9763_move_time_div(struct dw9763_device *dev_vcm,
					 unsigned int move_time_us)
{
	struct i2c_client *client = dev_vcm->client;
	unsigned int move_time = 0;

	switch (dev_vcm->t_div) {
	case 0:
		move_time = move_time_us * 2;
		break;
	case 1:
		move_time = move_time_us;
		break;
	case 2:
		move_time = move_time_us / 2;
		break;
	case 3:
		move_time = move_time_us / 4;
		break;
	case 4:
		move_time = move_time_us * 8;
		break;
	case 5:
		move_time = move_time_us * 4;
		break;
	default:
		dev_err(&client->dev,
			"%s: t_div parameter err %d\n",
			__func__, dev_vcm->t_div);
		break;
	}
	return move_time;
}

static unsigned int dw9763_move_time(struct dw9763_device *dev_vcm,
	unsigned int move_pos)
{
	struct i2c_client *client = dev_vcm->client;
	unsigned int move_time_us = 0;

	switch (dev_vcm->step_mode) {
	case SAC1_MODE:
	case SAC2_MODE:
	case SAC2_5_MODE:
	case SAC3_MODE:
	case SAC4_MODE:
		move_time_us = 6300 + dev_vcm->t_src * 100;
		move_time_us = dw9763_move_time_div(dev_vcm, move_time_us);
		break;
	case DIRECT_MODE:
		move_time_us = 30000;
		break;
	default:
		dev_err(&client->dev,
			"%s: step_mode is error %d\n",
			__func__, dev_vcm->step_mode);
		break;
	}

	dev_err(&client->dev,
		"%s: vcm_movefull_t is: %d us\n",
		__func__, move_time_us);

	return move_time_us;
}

static int dw9763_get_pos(struct dw9763_device *dev_vcm,
	unsigned int *cur_pos)
{
	struct i2c_client *client = dev_vcm->client;
	int ret;
	unsigned int abs_step;

	ret = dw9763_read_reg(client, 0x03, 2, &abs_step);
	if (ret != 0)
		goto err;

	if (abs_step <= dev_vcm->start_current)
		abs_step = VCMDRV_MAX_LOG;
	else if ((abs_step > dev_vcm->start_current) &&
		 (abs_step <= dev_vcm->rated_current))
		abs_step = (dev_vcm->rated_current - abs_step) / dev_vcm->step;
	else
		abs_step = 0;

	*cur_pos = abs_step;
	dev_dbg(&client->dev, "%s: get position %d\n", __func__, *cur_pos);
	return 0;

err:
	dev_err(&client->dev,
		"%s: failed with error %d\n", __func__, ret);
	return ret;
}

static int dw9763_set_pos(struct dw9763_device *dev_vcm,
	unsigned int dest_pos)
{
	int ret;
	unsigned int position = 0;
	struct i2c_client *client = dev_vcm->client;
	u32 is_busy, i;

	if (dest_pos >= VCMDRV_MAX_LOG)
		position = dev_vcm->start_current;
	else
		position = dev_vcm->start_current +
			   (dev_vcm->step * (VCMDRV_MAX_LOG - dest_pos));

	if (position > DW9763_MAX_REG)
		position = DW9763_MAX_REG;

	dev_vcm->current_lens_pos = position;
	dev_vcm->current_related_pos = dest_pos;
	for (i = 0; i < 100; i++) {
		ret = dw9763_read_reg(client, 0x05, 1, &is_busy);
		if (!ret && !(is_busy & 0x01))
			break;
		usleep_range(100, 200);
	}

	ret = dw9763_write_reg(client, 0x03, 2, dev_vcm->current_lens_pos);
	if (ret != 0)
		goto err;
	return ret;
err:
	dev_err(&client->dev,
		"%s: failed with error %d\n", __func__, ret);
	return ret;
}

static int dw9763_get_ctrl(struct v4l2_ctrl *ctrl)
{
	struct dw9763_device *dev_vcm = to_dw9763_vcm(ctrl);

	if (ctrl->id == V4L2_CID_FOCUS_ABSOLUTE)
		return dw9763_get_pos(dev_vcm, &ctrl->val);

	return -EINVAL;
}

static int dw9763_set_ctrl(struct v4l2_ctrl *ctrl)
{
	struct dw9763_device *dev_vcm = to_dw9763_vcm(ctrl);
	struct i2c_client *client = dev_vcm->client;
	unsigned int dest_pos = ctrl->val;
	int move_pos;
	long mv_us;
	int ret = 0;

	if (ctrl->id == V4L2_CID_FOCUS_ABSOLUTE) {

		if (dest_pos > VCMDRV_MAX_LOG) {
			dev_info(&client->dev,
				"%s dest_pos is error. %d > %d\n",
				__func__, dest_pos, VCMDRV_MAX_LOG);
			return -EINVAL;
		}
		/* calculate move time */
		move_pos = dev_vcm->current_related_pos - dest_pos;
		if (move_pos < 0)
			move_pos = -move_pos;

		ret = dw9763_set_pos(dev_vcm, dest_pos);

		dev_vcm->move_us = dev_vcm->vcm_movefull_t;

		dev_info(&client->dev,"dest_pos %d, move_us %ld\n",
			dest_pos, dev_vcm->move_us);

		dev_vcm->start_move_tv = ns_to_kernel_old_timeval(ktime_get_ns());
		mv_us = dev_vcm->start_move_tv.tv_usec +
				dev_vcm->move_us;
		if (mv_us >= 1000000) {
			dev_vcm->end_move_tv.tv_sec =
				dev_vcm->start_move_tv.tv_sec + 1;
			dev_vcm->end_move_tv.tv_usec = mv_us - 1000000;
		} else {
			dev_vcm->end_move_tv.tv_sec =
					dev_vcm->start_move_tv.tv_sec;
			dev_vcm->end_move_tv.tv_usec = mv_us;
		}
	}

	return ret;
}

static const struct v4l2_ctrl_ops dw9763_vcm_ctrl_ops = {
	.g_volatile_ctrl = dw9763_get_ctrl,
	.s_ctrl = dw9763_set_ctrl,
};

static int dw9763_open(struct v4l2_subdev *sd, struct v4l2_subdev_fh *fh)
{
	int rval;

	rval = pm_runtime_get_sync(sd->dev);
	if (rval < 0) {
		pm_runtime_put_noidle(sd->dev);
		return rval;
	}

	return 0;
}

static int dw9763_close(struct v4l2_subdev *sd, struct v4l2_subdev_fh *fh)
{
	pm_runtime_put(sd->dev);

	return 0;
}

static const struct v4l2_subdev_internal_ops dw9763_int_ops = {
	.open = dw9763_open,
	.close = dw9763_close,
};

static void dw9763_update_vcm_cfg(struct dw9763_device *dev_vcm)
{
	struct i2c_client *client = dev_vcm->client;
	int cur_dist;

	if (dev_vcm->max_ma == 0) {
		dev_err(&client->dev, "max current is zero");
		return;
	}

	cur_dist = dev_vcm->vcm_cfg.rated_ma - dev_vcm->vcm_cfg.start_ma;
	cur_dist = cur_dist * DW9763_MAX_REG / dev_vcm->max_ma;
	dev_vcm->step = (cur_dist + (VCMDRV_MAX_LOG - 1)) / VCMDRV_MAX_LOG;
	dev_vcm->start_current = dev_vcm->vcm_cfg.start_ma *
				 DW9763_MAX_REG / dev_vcm->max_ma;
	dev_vcm->rated_current = dev_vcm->vcm_cfg.rated_ma *
				 DW9763_MAX_REG / dev_vcm->max_ma;
	dev_vcm->step_mode = dev_vcm->vcm_cfg.step_mode;

	dev_info(&client->dev,
		"vcm_cfg: %d, %d, %d, max_ma %d\n",
		dev_vcm->vcm_cfg.start_ma,
		dev_vcm->vcm_cfg.rated_ma,
		dev_vcm->vcm_cfg.step_mode,
		dev_vcm->max_ma);
}

static long dw9763_ioctl(struct v4l2_subdev *sd, unsigned int cmd, void *arg)
{
	struct dw9763_device *dev_vcm = sd_to_dw9763_vcm(sd);
	struct i2c_client *client = dev_vcm->client;
	struct rk_cam_vcm_tim *vcm_tim;
	struct rk_cam_vcm_cfg *vcm_cfg;
	int ret = 0;

	if (cmd == RK_VIDIOC_VCM_TIMEINFO) {
		vcm_tim = (struct rk_cam_vcm_tim *)arg;

		vcm_tim->vcm_start_t.tv_sec = dev_vcm->start_move_tv.tv_sec;
		vcm_tim->vcm_start_t.tv_usec =
				dev_vcm->start_move_tv.tv_usec;
		vcm_tim->vcm_end_t.tv_sec = dev_vcm->end_move_tv.tv_sec;
		vcm_tim->vcm_end_t.tv_usec = dev_vcm->end_move_tv.tv_usec;

		dev_dbg(&client->dev, "dw9763_get_move_res 0x%lx, 0x%lx, 0x%lx, 0x%lx\n",
			vcm_tim->vcm_start_t.tv_sec,
			vcm_tim->vcm_start_t.tv_usec,
			vcm_tim->vcm_end_t.tv_sec,
			vcm_tim->vcm_end_t.tv_usec);
	} else if (cmd == RK_VIDIOC_GET_VCM_CFG) {
		vcm_cfg = (struct rk_cam_vcm_cfg *)arg;

		vcm_cfg->start_ma = dev_vcm->vcm_cfg.start_ma;
		vcm_cfg->rated_ma = dev_vcm->vcm_cfg.rated_ma;
		vcm_cfg->step_mode = dev_vcm->vcm_cfg.step_mode;
	} else if (cmd == RK_VIDIOC_SET_VCM_CFG) {
		vcm_cfg = (struct rk_cam_vcm_cfg *)arg;

		if (vcm_cfg->start_ma == 0 && vcm_cfg->rated_ma == 0) {
			dev_err(&client->dev,
				"vcm_cfg err, start_ma %d, rated_ma %d\n",
				vcm_cfg->start_ma, vcm_cfg->rated_ma);
			return -EINVAL;
		}
		dev_vcm->vcm_cfg.start_ma = vcm_cfg->start_ma;
		dev_vcm->vcm_cfg.rated_ma = vcm_cfg->rated_ma;
		dev_vcm->vcm_cfg.step_mode = vcm_cfg->step_mode;
		dw9763_update_vcm_cfg(dev_vcm);
	} else {
		dev_err(&client->dev,
			"cmd 0x%x not supported\n", cmd);
		return -EINVAL;
	}

	return ret;
}

#ifdef CONFIG_COMPAT
static long dw9763_compat_ioctl32(struct v4l2_subdev *sd,
	unsigned int cmd, unsigned long arg)
{
	struct dw9763_device *dev_vcm = sd_to_dw9763_vcm(sd);
	struct i2c_client *client = dev_vcm->client;
	void __user *up = compat_ptr(arg);
	struct rk_cam_compat_vcm_tim compat_vcm_tim;
	struct rk_cam_vcm_tim vcm_tim;
	struct rk_cam_vcm_cfg vcm_cfg;
	long ret;

	if (cmd == RK_VIDIOC_COMPAT_VCM_TIMEINFO) {
		struct rk_cam_compat_vcm_tim __user *p32 = up;

		ret = dw9763_ioctl(sd, RK_VIDIOC_VCM_TIMEINFO, &vcm_tim);
		compat_vcm_tim.vcm_start_t.tv_sec = vcm_tim.vcm_start_t.tv_sec;
		compat_vcm_tim.vcm_start_t.tv_usec = vcm_tim.vcm_start_t.tv_usec;
		compat_vcm_tim.vcm_end_t.tv_sec = vcm_tim.vcm_end_t.tv_sec;
		compat_vcm_tim.vcm_end_t.tv_usec = vcm_tim.vcm_end_t.tv_usec;

		put_user(compat_vcm_tim.vcm_start_t.tv_sec,
			&p32->vcm_start_t.tv_sec);
		put_user(compat_vcm_tim.vcm_start_t.tv_usec,
			&p32->vcm_start_t.tv_usec);
		put_user(compat_vcm_tim.vcm_end_t.tv_sec,
			&p32->vcm_end_t.tv_sec);
		put_user(compat_vcm_tim.vcm_end_t.tv_usec,
			&p32->vcm_end_t.tv_usec);
	} else if (cmd == RK_VIDIOC_GET_VCM_CFG) {
		ret = dw9763_ioctl(sd, RK_VIDIOC_GET_VCM_CFG, &vcm_cfg);
		if (!ret) {
			ret = copy_to_user(up, &vcm_cfg, sizeof(vcm_cfg));
			if (ret)
				ret = -EFAULT;
		}
	} else if (cmd == RK_VIDIOC_SET_VCM_CFG) {
		ret = copy_from_user(&vcm_cfg, up, sizeof(vcm_cfg));
		if (!ret)
			ret = dw9763_ioctl(sd, cmd, &vcm_cfg);
		else
			ret = -EFAULT;
	} else {
		dev_err(&client->dev,
			"cmd 0x%x not supported\n", cmd);
		return -EINVAL;
	}

	return ret;
}
#endif

static const struct v4l2_subdev_core_ops dw9763_core_ops = {
	.ioctl = dw9763_ioctl,
#ifdef CONFIG_COMPAT
	.compat_ioctl32 = dw9763_compat_ioctl32
#endif
};

static const struct v4l2_subdev_ops dw9763_ops = {
	.core = &dw9763_core_ops,
};

static void dw9763_subdev_cleanup(struct dw9763_device *dw9763_dev)
{
	v4l2_device_unregister_subdev(&dw9763_dev->sd);
	v4l2_device_unregister(&dw9763_dev->vdev);
	v4l2_ctrl_handler_free(&dw9763_dev->ctrls_vcm);
	media_entity_cleanup(&dw9763_dev->sd.entity);
}

static int dw9763_init_controls(struct dw9763_device *dev_vcm)
{
	struct v4l2_ctrl_handler *hdl = &dev_vcm->ctrls_vcm;
	const struct v4l2_ctrl_ops *ops = &dw9763_vcm_ctrl_ops;

	v4l2_ctrl_handler_init(hdl, 1);

	v4l2_ctrl_new_std(hdl, ops, V4L2_CID_FOCUS_ABSOLUTE,
			  0, VCMDRV_MAX_LOG, 1, 32);

	if (hdl->error)
		dev_err(dev_vcm->sd.dev, "%s fail error: 0x%x\n",
			__func__, hdl->error);
	dev_vcm->sd.ctrl_handler = hdl;
	return hdl->error;
}

#if 0
static int __dw9763_set_power(struct dw9763_device *dw9763_dev, bool on)
{
	if (dw9763_dev->vcc_gpio)
		gpio_set_value(dw9763_dev->vcc_gpio, on);

	printk("gpio_get_value(dw9763_dev->vcc_gpio) %d \n", gpio_get_value(dw9763_dev->vcc_gpio));
	return 0;
}


static int dw9763_check_id(struct dw9763_device *dw9763_dev)
{
	int ret = 0;
	unsigned int pid = 0x00;
	struct i2c_client *client = dw9763_dev->client;
	struct device *dev = &client->dev;

	__dw9763_set_power(dw9763_dev, true);
	ret = dw9763_read_reg(client, DW9763_REG_CHIP_ID, 1, &pid);

	if (pid != DW9763_CHIP_ID) {
		dev_err(dev, "Unexpected sensor id(%06x), ret(%d)\n", pid, ret);
		return -ENODEV;
	}

	dev_info(&dw9763_dev->client->dev,
		 "Detected dw9763 vcm id:0x%x\n", DW9763_CHIP_ID);
	return 0;
}

static int dw9763_probe_init(struct i2c_client *client)
{
	int ret = 0;

	/* Default goto power down mode when finished probe */
	ret = dw9763_write_reg(client, 0x02, 1, 0x01);
	if (ret)
		goto err;

	return 0;
err:
	dev_err(&client->dev, "probe init failed with error %d\n", ret);
	return -1;
}

static ssize_t  AF_HW_DumpReg_To_Proc(struct file *file, char __user *page, size_t size, loff_t *ppos)
{

	int ret = 0;
	unsigned int pid = 0x00;
   	char *ptr = page;
	unsigned int InitPos;    

    dw9763_read_reg(dw9763_client, 0x03, 2, &InitPos);
	
	ret = dw9763_read_reg(dw9763_client, DW9763_REG_CHIP_ID, 1, &pid);

	if (pid != DW9763_CHIP_ID) {
		dev_err(&dw9763_client->dev, "Unexpected sensor id(%06x), ret(%d)\n", pid, ret);
		return -ENODEV;
	}

	dev_info(&dw9763_client->dev,
		 "Detected dw9763 vcm id:0x%x\n", DW9763_CHIP_ID);
    
    return 0;
	
	

}
static ssize_t  AF_HW_Reg_Debug(struct file *file, const char *buffer, size_t count,
                         loff_t *data)
{
    char regBuf[64] = {'\0'};
    u32 u4CopyBufSize = (count < (sizeof(regBuf) - 1)) ? (count) : (sizeof(regBuf) - 1);
	int position = 0;

    if (copy_from_user(regBuf, buffer, u4CopyBufSize))
    return -EFAULT;

    if (sscanf(regBuf, "%x",  &position) == 1) {
		printk("====>position %d\n",position);
    	dw9763_write_reg(dw9763_client, 0x03, 2, position);
    }

    return count;
}

static  struct proc_ops af_proc_fops = {
    .proc_read = AF_HW_DumpReg_To_Proc,
    .proc_write = AF_HW_Reg_Debug
};
#endif

static int dw9763_probe(struct i2c_client *client,
			const struct i2c_device_id *id)
{
	struct device_node *np = of_node_get(client->dev.of_node);
	struct dw9763_device *dw9763_dev;
	unsigned int max_ma, start_ma, rated_ma, step_mode;
	unsigned int t_src, t_div;
	struct v4l2_subdev *sd;
	char facing[2];
	int ret;

	dw9763_client = client;
	dev_info(&client->dev, "probing...\n");
	if (of_property_read_u32(np,
		OF_CAMERA_VCMDRV_MAX_CURRENT,
		(unsigned int *)&max_ma)) {
		max_ma = DW9763_MAX_CURRENT;
		dev_info(&client->dev,
			"could not get module %s from dts!\n",
			OF_CAMERA_VCMDRV_MAX_CURRENT);
	}
	if (max_ma == 0)
		max_ma = DW9763_MAX_CURRENT;

	if (of_property_read_u32(np,
		OF_CAMERA_VCMDRV_START_CURRENT,
		(unsigned int *)&start_ma)) {
		start_ma = DW9763_DEFAULT_START_CURRENT;
		dev_info(&client->dev,
			"could not get module %s from dts!\n",
			OF_CAMERA_VCMDRV_START_CURRENT);
	}
	if (of_property_read_u32(np,
		OF_CAMERA_VCMDRV_RATED_CURRENT,
		(unsigned int *)&rated_ma)) {
		rated_ma = DW9763_DEFAULT_RATED_CURRENT;
		dev_info(&client->dev,
			"could not get module %s from dts!\n",
			OF_CAMERA_VCMDRV_RATED_CURRENT);
	}
	if (of_property_read_u32(np,
		OF_CAMERA_VCMDRV_STEP_MODE,
		(unsigned int *)&step_mode)) {
		step_mode = DW9763_DEFAULT_STEP_MODE;
		dev_info(&client->dev,
			"could not get module %s from dts!\n",
			OF_CAMERA_VCMDRV_STEP_MODE);
	}

	if (of_property_read_u32(np,
		OF_CAMERA_VCMDRV_T_SRC,
		(unsigned int *)&t_src)) {
		t_src = DW9763_DEFAULT_T_SACT;
		dev_info(&client->dev,
			"could not get module %s from dts!\n",
			OF_CAMERA_VCMDRV_T_SRC);
	}

	if (of_property_read_u32(np,
		OF_CAMERA_VCMDRV_T_DIV,
		(unsigned int *)&t_div)) {
		t_div = DW9763_DEFAULT_T_DIV;
		dev_info(&client->dev,
			"could not get module %s from dts!\n",
			OF_CAMERA_VCMDRV_T_DIV);
	}

	dw9763_dev = devm_kzalloc(&client->dev, sizeof(*dw9763_dev),
				  GFP_KERNEL);
	if (dw9763_dev == NULL)
		return -ENOMEM;

	ret = of_property_read_u32(np, RKMODULE_CAMERA_MODULE_INDEX,
				   &dw9763_dev->module_index);
	ret |= of_property_read_string(np, RKMODULE_CAMERA_MODULE_FACING,
				       &dw9763_dev->module_facing);
	if (ret) {
		dev_err(&client->dev,
			"could not get module information!\n");
		return -EINVAL;
	}
	dw9763_dev->client = client;
#if 0
	dw9763_dev->power_gpio = devm_gpiod_get(&client->dev,
					"power", GPIOD_OUT_LOW);
	if (IS_ERR(dw9763_dev->power_gpio)) {
		dw9763_dev->power_gpio = NULL;
		dev_warn(&client->dev,
			"Failed to get power-gpios, maybe no use\n");
	}
#endif


#if 0
	dw9763_dev->vcc_gpio = of_get_named_gpio(np, "vdd-gpio", 0);
	if (!gpio_is_valid(dw9763_dev->vcc_gpio)){
		dev_err(&client->dev,"failed to get vcc gpio!\n");
	}
	ret = dw9763_check_id(dw9763_dev);
	if (ret)
		goto err_power_off;

	/* enter power down mode */
	dw9763_probe_init(client);
	if (gpio_is_valid(dw9763_dev->vcc_gpio)){
		gpio_free(dw9763_dev->vcc_gpio);
		dev_err(&client->dev,"====>free vcc gpio!\n");
	}
#endif
	v4l2_i2c_subdev_init(&dw9763_dev->sd, client, &dw9763_ops);
	dw9763_dev->sd.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE;
	dw9763_dev->sd.internal_ops = &dw9763_int_ops;

	ret = dw9763_init_controls(dw9763_dev);
	if (ret)
		goto err_cleanup;

	ret = media_entity_pads_init(&dw9763_dev->sd.entity, 0, NULL);
	if (ret < 0)
		goto err_cleanup;

	sd = &dw9763_dev->sd;
	sd->entity.function = MEDIA_ENT_F_LENS;

	memset(facing, 0, sizeof(facing));
	if (strcmp(dw9763_dev->module_facing, "back") == 0)
		facing[0] = 'b';
	else
		facing[0] = 'f';

	snprintf(sd->name, sizeof(sd->name), "m%02d_%s_%s %s",
		 dw9763_dev->module_index, facing,
		 DW9763_NAME, dev_name(sd->dev));
	ret = v4l2_async_register_subdev(sd);
	if (ret)
		dev_err(&client->dev, "v4l2 async register subdev failed\n");

	dw9763_dev->max_ma = max_ma;
	dw9763_dev->vcm_cfg.start_ma = start_ma;
	dw9763_dev->vcm_cfg.rated_ma = rated_ma;
	dw9763_dev->vcm_cfg.step_mode = step_mode;
	dw9763_update_vcm_cfg(dw9763_dev);
	dw9763_dev->move_us	= 0;
	dw9763_dev->current_related_pos = VCMDRV_MAX_LOG;
	dw9763_dev->start_move_tv = ns_to_kernel_old_timeval(ktime_get_ns());
	dw9763_dev->end_move_tv = ns_to_kernel_old_timeval(ktime_get_ns());

	dw9763_dev->t_src = t_src;
	dw9763_dev->t_div = t_div;

	i2c_set_clientdata(client, dw9763_dev);
	mutex_init(&dw9763_dev->lock);

	dw9763_dev->vcm_movefull_t =
		dw9763_move_time(dw9763_dev, DW9763_MAX_REG);
	pm_runtime_set_active(&client->dev);
	pm_runtime_enable(&client->dev);
	pm_runtime_idle(&client->dev);

	//proc_create("driver/af", 0644, NULL, &af_proc_fops);
	dev_info(&client->dev, "probing successful\n");

	return 0;
err_cleanup:
	dw9763_subdev_cleanup(dw9763_dev);
#if 0
err_power_off:
	__dw9763_set_power(dw9763_dev, false);
	if (gpio_is_valid(dw9763_dev->vcc_gpio)){
		gpio_free(dw9763_dev->vcc_gpio);
		dev_err(&client->dev,"====>free vcc gpio!\n");
	}
#endif
	dev_err(&client->dev, "Probe failed: %d\n", ret);

	return ret;
}

static int dw9763_remove(struct i2c_client *client)
{
	struct dw9763_device *dw9763_dev = i2c_get_clientdata(client);

	mutex_destroy(&dw9763_dev->lock);
	pm_runtime_disable(&client->dev);
	dw9763_subdev_cleanup(dw9763_dev);

	return 0;
}

static int dw9763_init(struct i2c_client *client)
{
	struct dw9763_device *dev_vcm = i2c_get_clientdata(client);
	int ret = 0;
	u32 ring = 0;
	u32 mode_val = 0;
	u32 algo_time = 0;


	/* Delay 200us~300us */
	usleep_range(200, 300);
	ret = dw9763_write_reg(client, 0x02, 1, 0x00);
	if (ret)
		goto err;
	usleep_range(100, 200);

	if (dev_vcm->step_mode != DIRECT_MODE)
		ring = 0x02;
	ret = dw9763_write_reg(client, 0x02, 1, ring);
	if (ret)
		goto err;

	mode_val |= dev_vcm->step_mode << 5;

	mode_val |= ((dev_vcm->t_div ) & 0x07);
	algo_time = dev_vcm->t_src;
	ret = dw9763_write_reg(client, 0x06, 1, mode_val);
	if (ret)
		goto err;
	ret = dw9763_write_reg(client, 0x07, 1, algo_time);
	if (ret)
		goto err;
	usleep_range(100, 200);

	return 0;
err:
	dev_err(&client->dev, "init failed with error %d\n", ret);
	return -1;
}

static int __maybe_unused dw9763_vcm_suspend(struct device *dev)
{
	struct i2c_client *client = to_i2c_client(dev);
	int ret = 0;

	/* set to power down mode */
	ret = dw9763_write_reg(client, 0x02, 1, 0x01);
	if (ret)
		dev_err(&client->dev, "failed to set power down mode!\n");

	return 0;
}

static int __maybe_unused dw9763_vcm_resume(struct device *dev)
{
	struct i2c_client *client = to_i2c_client(dev);
	struct dw9763_device *dev_vcm = i2c_get_clientdata(client);

	dw9763_init(client);
	dw9763_set_pos(dev_vcm, dev_vcm->current_related_pos);
	return 0;
}

static const struct i2c_device_id dw9763_id_table[] = {
	{ DW9763_NAME, 0 },
	{ { 0 } }
};
MODULE_DEVICE_TABLE(i2c, dw9763_id_table);

static const struct of_device_id dw9763_of_table[] = {
	{ .compatible = "dongwoon,dw9763" },
	{ { 0 } }
};
MODULE_DEVICE_TABLE(of, dw9763_of_table);

static const struct dev_pm_ops dw9763_pm_ops = {
	SET_SYSTEM_SLEEP_PM_OPS(dw9763_vcm_suspend, dw9763_vcm_resume)
	SET_RUNTIME_PM_OPS(dw9763_vcm_suspend, dw9763_vcm_resume, NULL)
};

static struct i2c_driver dw9763_i2c_driver = {
	.driver = {
		.name = DW9763_NAME,
		.pm = &dw9763_pm_ops,
		.of_match_table = dw9763_of_table,
	},
	.probe = &dw9763_probe,
	.remove = &dw9763_remove,
	.id_table = dw9763_id_table,
};

module_i2c_driver(dw9763_i2c_driver);

MODULE_DESCRIPTION("DW9763 VCM driver");
MODULE_LICENSE("GPL");

首先开机注册为subdev

grep -H '' /sys/class/video4linux/v4l-subdev*/name
/sys/class/video4linux/v4l-subdev0/name:rockchip-mipi-csi2
/sys/class/video4linux/v4l-subdev1/name:rockchip-csi2-dphy0
/sys/class/video4linux/v4l-subdev10/name:rkisp-isp-subdev
/sys/class/video4linux/v4l-subdev11/name:rkcif-mipi-lvds1
/sys/class/video4linux/v4l-subdev2/name:m00_b_ov13855 4-0010
/sys/class/video4linux/v4l-subdev3/name:m00_b_dw9763 4-000c
/sys/class/video4linux/v4l-subdev4/name:rkisp-isp-subdev
/sys/class/video4linux/v4l-subdev5/name:rkcif-mipi-lvds
/sys/class/video4linux/v4l-subdev6/name:rockchip-mipi-csi2
/sys/class/video4linux/v4l-subdev7/name:rockchip-csi2-dphy1
/sys/class/video4linux/v4l-subdev8/name:m01_f_ov13855 5-0010
/sys/class/video4linux/v4l-subdev9/name:m01_f_dw9763 5-000c

在改写的过程中需要根据DW9763 datasheet中的寄存器进行模式设置、position写入读出设置，可以写一个proc文件或者sys文件，在camera打开后通过proc或sys节点操作寄存器，看看是否读写成功

另外改写驱动需要了解是怎么设置马达推动到哪里的，像展讯和MTK平台的是直接写寄存器的值，而rockchip平台下发到驱动中的是步数，可以在函数dw9763_update_vcm_cfg中看到，整个推动可以分为64步，在dw9763_set_pos时通过步数计算出具体的postion，再设置到寄存器里，至于移动时间就不再赘述，具体可以查看代码，每个模式的移动时间都是固定的，在马达正常工作后，打开camera会自动对焦，不断的调用dw9763_set_pos

2.4 前摄设置

这里我用的前摄也是ov13855，我们先通过之前的步骤让前摄能单独点亮后，再加上后摄，在camera3_profiles.xml文件中添加设置<Profiles cameraId=“1” name=“ov13855” moduleId=“m01”>
为了做到一套固件兼容多种硬件配置，可将所有有可能使用到的 camera 都配置上，只需注意moduleId 升序排列即可，允许存在相同的 moudleId，但不允许有相同 moduleId 的 camera 能同时 probe 到的情况

至此camera bringup基本完成，可能还有其他的如flashlight或IR需要调试

后面有需要可以把rockchip camera hal的代码过一遍

RK3588平台开发系列讲解（Camera篇）使用v4l2-ctl抓图
内核笔记
02-08 2499
📢本篇章主要讲解如何使用v4l2-ctl抓图。
RK3588平台Camera MIPI-CSI驱动调试思路分析
最新发布
bingdund的博客
03-18 315
MIPI联盟即移动产业处理器接口（Mobile Industry Processor Interface 简称MIPI）联盟。MIPI（移动产业处理器接口）是 MIPI联盟发起的为移动应用处理器制定的开放标准和一个规范。目的是把手机内部的接口如摄像头、显示屏接口、射频/基带接口等标准化，从而减少手机设计的复杂程度和增加设计灵活性。• （CSI）( Camera Serial Interface )：摄像头接口。
【RK3588 开发笔记——mipi摄像头调试】
W_B_C的博客
11-14 1万+
【RK3588 开发笔记——mipi摄像头调试】
ov13855在rk3588上设备树配置及显示图像偏绿
勿忘初心
07-17 2962
ov13855在rk3588上设备树配置 解决mipi摄像头ov13855显示图像偏绿
RK3588s camera点亮系列（一）驱动框架简介
zongheng_raobo的博客
07-09 1190
作为rk3588 camera点亮系列的开篇，本文主要介绍rk3588 视频输入子模块的驱动框架
瑞芯微RK3588平台 如何点亮camera
bingdund的博客
02-19 305
1.1 sensor的chipID可以通过i2c正确读取到，也就是i2c可以正常通信；1.2 使用media-ctl工具可以看到pipeline，可以看到sensor具体的分辨率和格式；1.3 使用V4L2工具抓图没有报错，有正常的数据输出，且使用V4L2的命令可以实现曝光增益等的控制，即可认为驱动没问题；1.4 xml配置SOC模式下，使用apk可以预览出图（图像可能会偏暗偏绿，后续再讲xml如何配置），到这一步可认为HAL没问题1.5 自行移植其他sensor的效果文件，可以出图。
Camera 驱动 Bringup
程序员Android
09-26 3718
和你一起终身学习，这里是程序员Android经典好文推荐，通过阅读本文，您将收获以下知识点:一、Kernel 代码移植二、Vendor 代码移植三、扩展一、Kernel 代码移植1. DT...
高通camera bring up软件流程
产品线负责人
04-29 7124
高通camera bring up分为两种类型：YUV和bayer bring up yuv sensor 1、kernel空间 1) vim kernel/driver/media/platform/msm/camera_v2/sensor 添加sensor驱动文件-可参考其他 修改Makefile 2) kernel/arch/arm/configs 添加CONFIG_定义 3
基础：高通bring up camera
产品线负责人
11-06 5875
bring UP 需要做的工作 1、kernelspace sensor driver ： 驱动和设备树 2、userspace camera 对应的chromatix library 和sensor library 准备工作 1、模组原理图 2、sensor spec 3、sensor resolution 代码准备 1、kerne
Qualcomm camera bring up
liaokesen168的博客
12-27 3816
Qualcomm camera bring up 1 kernel层 11 电源时钟RESET管脚等配置dtsi配置 2 hal层 21 添加驱动文件 22 添加效果文件 23 添加sensor_chromatixxml配置文件 24 配置projectplatform_cameraxml文件 25 把前面所有make file中的LOCAL_MODU
RK3588平台HDMIRX功能Bringup
IMGDX的博客
05-26 4163
本文档是基于RK3588 Android 12平台使用HDMI RX模块开发指南。
【移植】标准系统方案之瑞芯微RK3568移植案例(一)
CTrup的博客
08-30 774
主要完成 Codec/DMA/I2S 驱动注册，使得 ADM 可以加载驱动节点；并注册 ADM 与 Drivers 交互的接口函数主要完成 ADM Drivers adapter 接口函数的实现，以及 Codec_config.hcs/dai_config.hcs 等配置信息的获取，并注册到对应的设备ADM Drivers impl 可以直接阅读硬件手册，完成驱动端到端的配置；也可以借用 Linux 原生驱动实现与接口，减少开发者工作量。
【麒麟系统瑞芯微显示和GPU配置】
qq_17414927的博客
12-18 1494
瑞芯微平台rk356x/rk3588分别对应arm gpu的G52和G610的显卡，另外rockchip携带对应的2d加速模块。如果采用的是xorg的显示方案的话，其实加速方案有以下几种：第一种：通过2d模块也就是rga模块(rga2/rga3)进行加速，其中瑞芯微提供两种方式一种是xorg的exa加速方案(在2d加速模块使用主推)，另外一种就是pixman通过rga进行加速，可以参考rockchip的作者jeffycn的pixman的加速方案(实际我这边并未测试过该方案)。
rk3568 Android 适配红外遥控器
weixin_35723192的博客
04-04 1538
内核日志太多，可使用adb 命令过滤直接得到键值。USERCODE 添加遥控dts 对应的 rockchip,usercode，RMC_GETDATA 对应键值可通过rockchip,key_table 转换为rk-input键值。adb root;字母和符号键都是 linux 的标准键值，在可以在 include/dt-bindings/input/input.h。详见2 input 键值表。
Rockchip开发系列 - 总目录
fulinux的博客
11-14 978
Rockchip开发系列 - 总目录
Linux Kernel入门到精通系列讲解 - 总目录
DSMGUOGUO的博客
03-14 9841
在学习Linux Kernel之前，需要先准备开发环境，方便后续进行开发。可以根据自身情况，选择性阅读该章节。学习该章节之前，你应该了解一下网络概念，明白为什么要讲这些，才能更有方向的去理解学习。Linux ARM平台开发系列讲解（设备树篇） 4.1.1 设备树的原理详解。本项目完全开源，仅供学习使用，如需其他用途，请与本人联系。），本章节你可以学习到。摄像头V4L2子系统、Linux kernel常用的子系统等，ARM架构、RISCV架构、Uboot等。
camera bringup介绍
weixin_42136255的博客
10-11 1796
camera bringup介绍
项目总结: RK356X Camera bring up
研究员的自我修养
11-26 788
项目总结: RK356X Camera bring up
Qualcomm平台camera调试移植入门
热门推荐
srw11的专栏
09-18 2万+
1  camera基本代码架构     高通平台对于camera的代码组织，大体上还是遵循Android的框架：即上层应用和HAL层交互，高通平台在HAL层里面实现自己的一套管理策略；在kernel中实现sensor的底层驱动。但是，对于最核心的sensor端的底层设置、ISP效果相关等代码则是单独进行了抽离，放在了一个daemon进程中进行管理： 图1Qualcomm平台ca
Rk 3588输出cameralink
05-23
RK8芯片本身不支持CameraLink输出，但是可以通过外部转换器将RK3588的接口转换成CameraLink输出。例如，可以使用像Intersil CP3850、Texas Instruments DS90UB913A-Q1或MAX96705等芯片来实现RK3588到CameraLink的转换。这些芯片都支持MIPI CSI接口，并且可以将其转换为CameraLink输出。需要注意的是，转换后的信号可能需要进行调整和优化才能满足CameraLink的要求。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

autho

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值