MTK Camera 上电流程简析

Linux老A

已于 2023-01-11 10:20:36 修改

阅读量5.4k

点赞数 7

分类专栏： Linux驱动文章标签： fpga开发

于 2019-06-13 18:44:40 首次发布

本文链接：https://blog.csdn.net/LinuxArmbiggod/article/details/91884229

版权

Linux驱动专栏收录该内容

36 篇文章 48 订阅

订阅专栏

一：硬件

二：Camera image sensor驱动模块驱动加载

三：上电分析

一硬件

二 : Camera image sensor驱动模块驱动加载

分五步走：

//HAl层命令通道
static long CAMERA_HW_Ioctl(
	struct file *a_pstFile,
	unsigned int a_u4Command,
	unsigned long a_u4Param
)
{

	switch (a_u4Command) {

	case KDIMGSENSORIOC_X_SET_DRIVER:
		i4RetValue = kdSetDriver((unsigned int *)pBuff);
		break;
	case KDIMGSENSORIOC_T_OPEN:
		i4RetValue = adopt_CAMERA_HW_Open();
		break;
	case KDIMGSENSORIOC_X_GETINFO:
		i4RetValue = adopt_CAMERA_HW_GetInfo(pBuff);
		break;
	case KDIMGSENSORIOC_X_GETRESOLUTION2:
		i4RetValue = adopt_CAMERA_HW_GetResolution(pBuff);
		break;
	case KDIMGSENSORIOC_X_GETINFO2:
		i4RetValue = adopt_CAMERA_HW_GetInfo2(pBuff);
		break;
	case KDIMGSENSORIOC_X_FEATURECONCTROL:
		i4RetValue = adopt_CAMERA_HW_FeatureControl(pBuff);
		break;
	case KDIMGSENSORIOC_X_CONTROL:
		i4RetValue = adopt_CAMERA_HW_Control(pBuff);
		break;
	case KDIMGSENSORIOC_T_CLOSE:
		i4RetValue = adopt_CAMERA_HW_Close();
		break;
	case KDIMGSENSORIOC_T_CHECK_IS_ALIVE:
		i4RetValue = adopt_CAMERA_HW_CheckIsAlive();
		break;
	case KDIMGSENSORIOC_X_GET_SOCKET_POS:
		i4RetValue = kdGetSocketPostion((unsigned int *)pBuff);
		break;
	case KDIMGSENSORIOC_X_SET_I2CBUS:
		/* i4RetValue = kdSetI2CBusNum(*pIdx); */
		break;
	case KDIMGSENSORIOC_X_RELEASE_I2C_TRIGGER_LOCK:
		/* i4RetValue = kdReleaseI2CTriggerLock(); */
		break;

	case KDIMGSENSORIOC_X_SET_SHUTTER_GAIN_WAIT_DONE:
		i4RetValue = kdSensorSetExpGainWaitDone((int *)pBuff);
		break;

	case KDIMGSENSORIOC_X_SET_CURRENT_SENSOR:
		i4RetValue = kdSetCurrentSensorIdx(*pIdx);
		break;

	case KDIMGSENSORIOC_X_SET_MCLK_PLL:
		i4RetValue = kdSetSensorMclk(pBuff);
		break;

	case KDIMGSENSORIOC_X_SET_GPIO:
		i4RetValue = kdSetSensorGpio(pBuff);
		break;

	case KDIMGSENSORIOC_X_GET_ISP_CLK:
		/* PK_DBG("get_isp_clk=%d\n",get_isp_clk()); */
		/* *(unsigned int*)pBuff = get_isp_clk(); */
		break;

	default:
		PK_DBG("No such command\n");
		i4RetValue = -EPERM;
		break;

	}

	return i4RetValue;
}
******************************************
第五步： 汇集于IOCTL

static long CAMERA_HW_Ioctl_Compat(struct file *filp, unsigned int cmd, unsigned long arg)
{
  ...
    /* Data in the following commands is not required to be converted to kernel 64-bit & user 32-bit */
    case KDIMGSENSORIOC_T_OPEN:
    case KDIMGSENSORIOC_T_CLOSE:
    case KDIMGSENSORIOC_T_CHECK_IS_ALIVE:
    case KDIMGSENSORIOC_X_SET_DRIVER:
    case KDIMGSENSORIOC_X_GET_SOCKET_POS:
    case KDIMGSENSORIOC_X_SET_I2CBUS:
    case KDIMGSENSORIOC_X_RELEASE_I2C_TRIGGER_LOCK:
    case KDIMGSENSORIOC_X_SET_SHUTTER_GAIN_WAIT_DONE:
    case KDIMGSENSORIOC_X_SET_MCLK_PLL:
    case KDIMGSENSORIOC_X_SET_CURRENT_SENSOR:
    case KDIMGSENSORIOC_X_SET_GPIO:
    case KDIMGSENSORIOC_X_GET_ISP_CLK:
    return filp->f_op->unlocked_ioctl(filp, cmd, arg);

    default:
    return -ENOIOCTLCMD;
    }
}


***********************************************************************************************

第四步 ： 分别实现自己的字符设备注册函数以及fops结构体，可以注意到 两个fops指向同一个 ioctl

//主摄像头字符设备 fops
static const struct file_operations g_stCAMERA_HW_fops = {
	.owner = THIS_MODULE,
	.open = CAMERA_HW_Open,
	.release = CAMERA_HW_Release,
	.unlocked_ioctl = CAMERA_HW_Ioctl,
#ifdef CONFIG_COMPAT
	.compat_ioctl = CAMERA_HW_Ioctl_Compat,
#endif

};

//副摄像头字符设备 fops
static const struct file_operations g_stCAMERA_HW_fops0 = {
	.owner = THIS_MODULE,
	.open = CAMERA_HW_Open2,
	.release = CAMERA_HW_Release2,
	.unlocked_ioctl = CAMERA_HW_Ioctl,
#ifdef CONFIG_COMPAT
	.compat_ioctl = CAMERA_HW_Ioctl_Compat,
#endif

};


//主摄像头字符设备 注册函数
static inline int RegisterCAMERA_HWCharDrv(void)
{


...常规字符设备创建过程...

	/* Attatch file operation. */
	cdev_init(g_pCAMERA_HW_CharDrv, &g_stCAMERA_HW_fops);

	g_pCAMERA_HW_CharDrv->owner = THIS_MODULE;

	/* Add to system */
	if (cdev_add(g_pCAMERA_HW_CharDrv, g_CAMERA_HWdevno, 1)) {
		PK_DBG("[mt6516_IDP] Attatch file operation failed\n");

		unregister_chrdev_region(g_CAMERA_HWdevno, 1);

		return -EAGAIN;
	}
	//创建目录 /sys/class/sensordrv/
	sensor_class = class_create(THIS_MODULE, "sensordrv");
	if (IS_ERR(sensor_class)) {
		int ret = PTR_ERR(sensor_class);
		PK_DBG("Unable to create class, err = %d\n", ret);
		return ret;
	}
	//创建目录/sys/class/sensordrv/kd_camera_hw
	sensor_device = device_create(sensor_class, NULL, g_CAMERA_HWdevno, NULL, CAMERA_HW_DRVNAME1);

	return 0;
}

//副摄像头字符设备 注册函数
static inline int RegisterCAMERA_HWCharDrv2(void)
{
	...常规字符设备创建过程...

	/* Attatch file operation. */
	cdev_init(g_pCAMERA_HW_CharDrv2, &g_stCAMERA_HW_fops0);

	g_pCAMERA_HW_CharDrv2->owner = THIS_MODULE;

	/* Add to system */
	if (cdev_add(g_pCAMERA_HW_CharDrv2, g_CAMERA_HWdevno2, 1)) {
		PK_DBG("[mt6516_IDP] Attatch file operation failed\n");

		unregister_chrdev_region(g_CAMERA_HWdevno2, 1);

		return -EAGAIN;
	}
	//创建目录 /sys/class/sensordrv2/
	sensor2_class = class_create(THIS_MODULE, "sensordrv2");
	if (IS_ERR(sensor2_class)) {
		int ret = PTR_ERR(sensor2_class);
		PK_DBG("Unable to create class, err = %d\n", ret);
		return ret;
	}
	//创建目录/sys/class/sensordrv/kd_camera_hw_bus2
	sensor_device = device_create(sensor2_class, NULL, g_CAMERA_HWdevno2, NULL, CAMERA_HW_DRVNAME2);

	return 0;
}

***********************************************************************************************

第三步： 在i2c prob()中分别注册字符设备驱动

static int CAMERA_HW_i2c_probe(struct i2c_client *client, const struct i2c_device_id *id)
{
	/* Register char driver  注册字符设备驱动 */
	i4RetValue = RegisterCAMERA_HWCharDrv();
}


static int CAMERA_HW_i2c_probe2(struct i2c_client *client, const struct i2c_device_id *id)
{
	/* Register char driver 注册字符设备驱动*/
	i4RetValue = RegisterCAMERA_HWCharDrv2();
}


*************************************************************************************************

第二步：在平台prob()中分别注册自己的I2C驱动，匹配cust_i2c.dtsi 中的i2c设备 mediatek,camera_main 以及 mediatek,camera_sub ，成功则调用各自的 i2c prob()


//主摄像头I2C设备
    static const struct of_device_id CAMERA_HW_i2c_of_ids[] = {
	    { .compatible = "mediatek,camera_main", },
	    {}
    };

struct i2c_driver CAMERA_HW_i2c_driver = {
	.probe = CAMERA_HW_i2c_probe,
	.remove = CAMERA_HW_i2c_remove,
	.driver = {
		.name = CAMERA_HW_DRVNAME1,
		.owner = THIS_MODULE,
		.of_match_table = CAMERA_HW_i2c_of_ids,
	},
	.id_table = CAMERA_HW_i2c_id,
};


//副摄像头I2C设备
    static const struct of_device_id CAMERA_HW2_i2c_driver_of_ids[] = {
	{ .compatible = "mediatek,camera_sub", },
	{}
    };


struct i2c_driver CAMERA_HW_i2c_driver2 = {
    .probe = CAMERA_HW_i2c_probe2,
    .remove = CAMERA_HW_i2c_remove2,
    .driver = {
    .name = CAMERA_HW_DRVNAME2,
    .owner = THIS_MODULE,
    .of_match_table = CAMERA_HW2_i2c_driver_of_ids,
    },
    .id_table = CAMERA_HW_i2c_id2,
};


static int CAMERA_HW_probe(struct platform_device *pdev)
{

    return i2c_add_driver(&CAMERA_HW_i2c_driver);
}


static int CAMERA_HW_probe2(struct platform_device *pdev)
{
	return i2c_add_driver(&CAMERA_HW_i2c_driver2);
}

***************************************************************************************************

第一步 ：CAMERA_HW_i2C_init中初始化，注册平台驱动，并且匹配dts mt6735.dtsi 中的平台设备 mediatek,camera_hw 以及 mediatek,camera_hw2，成功则调用 prob()

//主摄像头平台驱动 以及 匹配设备
static const struct of_device_id CAMERA_HW_of_ids[] = {
	{ .compatible = "mediatek,camera_hw", },
	{}
};
static struct platform_driver g_stCAMERA_HW_Driver = {
	.probe      = CAMERA_HW_probe,
	.remove     = CAMERA_HW_remove,
	.suspend    = CAMERA_HW_suspend,
	.resume     = CAMERA_HW_resume,
	.driver     = {
		.name   = "image_sensor",
		.owner  = THIS_MODULE,
#ifdef CONFIG_OF
		.of_match_table = CAMERA_HW_of_ids,
#endif
	}
};

//副像头平台驱动 以及 匹配设备
static const struct of_device_id CAMERA_HW2_of_ids[] = {
    { .compatible = "mediatek,camera_hw2", },
    {}
};
static struct platform_driver g_stCAMERA_HW_Driver2 = {
	.probe      = CAMERA_HW_probe2,
	.remove     = CAMERA_HW_remove2,
	.suspend    = CAMERA_HW_suspend2,
	.resume     = CAMERA_HW_resume2,
	.driver     = {
		.name   = "image_sensor_bus2",
		.owner  = THIS_MODULE,
#ifdef CONFIG_OF
    .of_match_table = CAMERA_HW2_of_ids,
#endif

	}
};

static int __init CAMERA_HW_i2C_init(void)
{
	//注册i2c设备
    i2c_register_board_info(SUPPORT_I2C_BUS_NUM1, &i2c_devs1, 1);
    i2c_register_board_info(SUPPORT_I2C_BUS_NUM2, &i2c_devs2, 1);

	//注册平台驱动
	platform_driver_register(&g_stCAMERA_HW_Driver)) 
	platform_driver_register(&g_stCAMERA_HW_Driver2)) 
}



module_init(CAMERA_HW_i2C_init);
module_exit(CAMERA_HW_i2C_exit);

cust_i2c.dtsi
	{

		&i2c0 {
			camera_main@10 {
				compatible = "mediatek,camera_main";
				reg = <0x10>;
			};

			camera_sub@3c {
				compatible = "mediatek,camera_sub";
				reg = <0x3c>;
			};

		};


	}





mt6735.dtsi
	{

		        kd_camera_hw1:kd_camera_hw1@15008000 {
		                compatible = "mediatek,camera_hw";
		                reg = <0x15008000 0x1000>;  /* SENINF_ADDR */
		                vcama-supply = <&mt_pmic_vcama_ldo_reg>;
		                vcamd-supply = <&mt_pmic_vcamd_ldo_reg>;
		                vcamaf-supply = <&mt_pmic_vcam_af_ldo_reg>;
		                vcamio-supply = <&mt_pmic_vcam_io_ldo_reg>;
		                /* Camera Common Clock Framework (CCF) */
		                clocks = <&topckgen TOP_MUX_CAMTG>,
		                <&topckgen TOP_UNIVPLL_D26>,
		                <&topckgen TOP_UNIVPLL2_D2>;
		                clock-names = "TOP_CAMTG_SEL","TOP_UNIVPLL_D26","TOP_UNIVPLL2_D2";
		        };

		        kd_camera_hw2:kd_camera_hw2@15008000 {
		                compatible = "mediatek,camera_hw2";
		                reg = <0x15008000 0x1000>;  /* SENINF_ADDR */
		        };


	}



xxxxx.dts
	{

		&kd_camera_hw1 {
			pinctrl-names = "default", "cam0_rst0", "cam0_rst1", "cam0_pnd0", "cam0_pnd1",
			"cam1_rst0", "cam1_rst1", "cam1_pnd0", "cam1_pnd1",
			"cam_ldo0_0", "cam_ldo0_1";
			pinctrl-0 = <&camera_pins_default>;
			pinctrl-1 = <&camera_pins_cam0_rst0>;
			pinctrl-2 = <&camera_pins_cam0_rst1>;
			pinctrl-3 = <&camera_pins_cam0_pnd0>;
			pinctrl-4 = <&camera_pins_cam0_pnd1>;
			pinctrl-5 = <&camera_pins_cam1_rst0>;
			pinctrl-6 = <&camera_pins_cam1_rst1>;
			pinctrl-7 = <&camera_pins_cam1_pnd0>;
			pinctrl-8 = <&camera_pins_cam1_pnd1>;
			pinctrl-9 = <&camera_pins_cam_ldo0_0>;
			pinctrl-10 = <&camera_pins_cam_ldo0_1>;
			status = "okay";

		};

	}

三上电分析

MTK Camera驱动 kernel 中的部分大致分为两层，核心层和设备层。

核心层又分为两小部分：

核心逻辑：
kernel/drivers/misc/mediatek/imgsensor/src/mt6735/kd_sensorlist.c //与HAL层通信交互
kernel/drivers/misc/mediatek/imgsensor/src/mt6735/kd_sensorlist.h
kernel/drivers/misc/mediatek/imgsensor/inc/kd_imgsensor_define.h
设备上电：
kernel/drivers/misc/mediatek/imgsensor/src/mt6735/camera_hw/kd_camera_hw.c //抽象出来的上电操作

设备层：sensor 驱动，寄存器操作
如：kernel/drivers/misc/mediatek/imgsensor/src/mt6735/camera_project/xxx/gc2023_mipi_raw/gc2023mipi_Sensor.c

关键数据结构之间的关系：

kernel-3.18/drivers/misc/mediatek/imgsensor/inc/kd_imgsensor_define.h 中定义了 

struct MULTI_SENSOR_FUNCTION_STRUCT2： 用于保存系统中的Sensor的操作方法，如 open 等等
struct SENSOR_FUNCTION_STRUCT : 用于保存系统中的Sensor的操作方法，如 open 等等
struct ACDK_KD_SENSOR_INIT_FUNCTION_STRU ： 用于保存系统中Sensor 的 Name、ID、Init()信息

问题：SENSOR_FUNCTION_STRUCT 和 MULTI_SENSOR_FUNCTION_STRUCT2 是一样的，为什么要重复定义呢？

答案：

MULTI_SENSOR_FUNCTION_STRUCT2 主要用于核心层 kd_sensorlist.c中，kd_sensorlist.c中同样封装了一个新的 MULTI_SENSOR_FUNCTION_STRUCT2，用于保存系统中的Sensor的操作方法，如 open。只是这些操作是核心层的操作，是整个系统的所有Camera 共用的，在这里面可以打开底层各个设备的 SENSOR_FUNCTION_STRUC操作方法集合。SENSOR_FUNCTION_STRUCT 主要用于设备层，设备层用SENSOR_FUNCTION_STRUCT封装操作自己的方法，供上层调用，这里指的上层就是核心层。

kd_sensorlist.c ： MULTI_SENSOR_FUNCTION_STRUCT2.open
		 调用
gc2023mipi_Sensor.c : SENSOR_FUNCTION_STRUCT sensor_func.open

kernel-3.18/drivers/misc/mediatek/imgsensor/src/mt6735/kd_sensorlist.h 中定义了

ACDK_KD_SENSOR_INIT_FUNCTION_STRUCT kdSensorList[MAX_NUM_OF_SUPPORT_SENSOR+1] =
{
	...
#if defined(GC2023_MIPI_YUV)
    {GC2023MIPI_SENSOR_ID, SENSOR_DRVNAME_GC2023_MIPI_YUV,GC2023MIPISensorInit},
#endif
	...
}

ACDK_KD_SENSOR_INIT_FUNCTION_STRUC定义于 kd_imgsensor_define.h。用于保存 Sensor ID Name Init函数等信息。这里的定义的结构体数组包含了系统所有的Camera的名称 ID 初始化函数的集合是系统 camera 信息表。如： {GC2023MIPI_SENSOR_ID, SENSOR_DRVNAME_GC2023_MIPI_YUV,GC2023MIPISensorInit},该数组元素的第一个项表示ID，第二项表示名称，第三项表示初始化函数。

总结：

系统首先是发送 IOCTL: KDIMGSENSORIOC_X_SET_DRIVER。这里面主要的工作是定义一个 ACDK_KD_SENSOR_INIT_FUNCTION_STRUCT指针然后调用 kdGetSensorInitFuncList()获取 kd_sensorlist.h中
定义的 kdSensorList[]系统 camera 信息表,接着便利该表，根据SensorID 绑定核心层的SENSOR_FUNCTION_STRUCT *g_pInvokeSensorFunc 与设备层的 SENSOR_FUNCTION_STRUCT sensor_func，这样就可以直接操作设备层的SENSOR_FUNCTION_STRUCT中的方法了。

然后发送 IOCTL: KDIMGSENSORIOC_T_OPEN 等一些列 IOCTL()，此时可以直接操作设备层中的方法了

我们主要分析 KDIMGSENSORIOC_T_OPEN和 KDIMGSENSORIOC_X_SET_DRIVER两个ioctl：

–
KDIMGSENSORIOC_X_SET_DRIVER 流程：

1 Hal层发送 ioctl(m_fdSensor, KDIMGSENSORIOC_X_SET_DRIVER, &sensorIdx); 

2 Kernel 接受 KDIMGSENSORIOC_X_SET_DRIVER指令，调用 kdSetDriver((unsigned int *)pBuff)

3 
	3.1 在本地创建 ACDK_KD_SENSOR_INIT_FUNCTION_STRUCT *pSensorList = NULL;
		说明：结构体 ACDK_KD_SENSOR_INIT_FUNCTION_STRUCT 定义在 kernel-3.18/drivers/misc/mediatek/imgsensor/inc/kd_imgsensor_define.h中，用于保存Camera的 ID、Name、Init函数 等信息
			该结构体于 kernel-3.18/drivers/misc/mediatek/imgsensor/src/mt6735/kd_sensorlist.h 创建  ACDK_KD_SENSOR_INIT_FUNCTION_STRUCT kdSensorList[MAX_NUM_OF_SUPPORT_SENSOR+1]
			结构体数组，理解为系统Camera信息表，用于保存整个系统的 Camera 的 ID、Name、Init函数 等信息。
		
	3.2 kdGetSensorInitFuncList(&pSensorList) ： 
		说明：获得 dSensorList[] 数组首地址，将 pSensorList指针 指向 src/kd_sensorlist.h里面 ，获取 kd_sensorlist.h中定义的系统Camera信息表。
			ACDK_KD_SENSOR_INIT_FUNCTION_STRUCT kdSensorList[MAX_NUM_OF_SUPPORT_SENSOR+1] 变量的首地址。即获取初始化列表地址

	3.3 g_bEnableDriver[i] = FALSE; 
		说明：先将 g_bEnableDriver[i]设置为 false

	3.4 g_invokeSocketIdx[i] = (CAMERA_DUAL_CAMERA_SENSOR_ENUM)((pDrvIndex[i] & KDIMGSENSOR_DUAL_MASK_MSB) >> KDIMGSENSOR_DUAL_SHIFT);
		说明：保存 camera的sensorId
		
	3.5 if (NULL == pSensorList[drvIdx[i]].SensorInit)
		说明：判断模块驱动的init函数是否为NULL

	3.6 pSensorList[drvIdx[i]].SensorInit(&g_pInvokeSensorFunc[i]);
		说明：传递 &g_pInvokeSensorFunc[i] 为参数,其中还是传递的地址,这就将g_pInvokeSensorFunc的首地址指向了模块驱动函数中的UINT32 GC2023MIPISensorInit(PSENSOR_FUNCTION_STRUCT *pfFunc)这个函数
			调用模块驱动中的init函数，将 g_pInvokeSensorFunc[sensor]指针指向 sensor模组的 SENSOR_FUNCTION_STRUCT。即绑定 sensor模组的 SENSOR_FUNCTION_STRUCT。

	3.7 g_bEnableDriver[i] = TRUE;
		说明：将 g_bEnableDrive[i] 设置为TRUE，表示与该g_bEnableDriver[i]对应的 sensor 可用。

KDIMGSENSORIOC_T_OPEN 流程：

1 Hal层发送 ioctl(m_fdSensor, KDIMGSENSORIOC_T_OPEN, &sensorIdx); 

2 Kernel 接受 KDIMGSENSORIOC_X_SET_DRIVER指令，调用 adopt_CAMERA_HW_Open()

3 adopt_CAMERA_HW_Open()中
	
	3.1 if (g_pSensorFunc) 
	说明：判断我们 imagesensor 操作函数指针是否为NULL，如果为NULL，报错，因为我们就是靠这个操作函数集合去操作imagesensor 的 
	
	3.2 err = g_pSensorFunc->SensorOpen();
	说明：会调用到 kd_MultiSensorFunc 里面的 kd_MultiSensorOpen 函数

4 MUINT32 kd_MultiSensorOpen(void)中
	4.1 if (g_bEnableDriver[i] && g_pInvokeSensorFunc[i]) 
	说明：
		4.1.1 g_bEnableDriver g_pInvokeSensorFunc[i] 这两个变量都为true时，就对sensor进行上电,然后就通过ret =g_pInvokeSensorFunc[i]->SensorOpen()进入到了模块sensor驱动中的open函数。

		4.1.2 这里可以看出hal调用ioctl命令时不可能先走 KDIMGSENSORIOC_T_OPEN 这个命令，因为此时 g_pInvokeSensorFunc 为 NULL，还没有绑定到模组的 SENSOR_FUNCTION_STRUCT sensor_func。
		所以这里代码无法执行，由后面的代码可以看到，ioctl先走的cmd命令是 KDIMGSENSORIOC_X_SET_DRIVER，在 KDIMGSENSORIOC_X_SET_DRIVER里面对 g_pInvokeSensorFunc进行初始化。

		4.1.3 于上电跟掉电函数 kdCISModulePowerOn，在 kernel-3.18/drivers/misc/mediatek/imgsensor/src/mt6735/camera_project/xxxx/camera_hw/kd_camera_hw.c文件中，其实上电跟掉电时序就是
			配置一些GPIO口，然后在把camera的三路电压按dateshell配置一下上掉电的时间。
	
	4.2 ret = kdCISModulePowerOn((CAMERA_DUAL_CAMERA_SENSOR_ENUM)g_invokeSocketIdx[i], (char *)g_invokeSensorNameStr[i], true, CAMERA_HW_DRVNAME1); 
	说明：上电

	4.3 ret = g_pInvokeSensorFunc[i]->SensorOpen();
	说明：调用到模块驱动中的open函数，g_pInvokeSensorFunc[i]保存的值为模块驱动中的static SENSOR_FUNCTION_STRUCT sensor_func这个结构体的指针(地址)

分析代码如下：罗列了主要的代码和数据结构。

kernel-3.18/drivers/misc/mediatek/imgsensor/src/mt6735/kd_sensorlist.c

/*
MULTI_SENSOR_FUNCTION_STRUCT2 和 SENSOR_FUNCTION_STRUCT一样，只不过为了把驱动抽象出来，核心层用MULTI_SENSOR_FUNCTION_STRUCT2。模组驱动层用MULTI_SENSOR_FUNCTION_STRUCT，
上电时会将这两个结构体绑定
*/
MULTI_SENSOR_FUNCTION_STRUCT2  kd_MultiSensorFunc = {
	kd_MultiSensorOpen,
	kd_MultiSensorGetInfo,
	kd_MultiSensorGetResolution,
	kd_MultiSensorFeatureControl,
	kd_MultiSensorControl,
	kd_MultiSensorClose
};


extern MULTI_SENSOR_FUNCTION_STRUCT2 kd_MultiSensorFunc;//imagesensor 操作函数集合
static MULTI_SENSOR_FUNCTION_STRUCT2 *g_pSensorFunc = &kd_MultiSensorFunc;//imagesensor 操作函数指针


/*
1 g_bEnableDriver 定义为一个bool型的变量
2 g_pInvokeSensorFunc 地址跟模块驱动中的 static SENSOR_FUNCTION_STRUCT sensor_func 这个地址指向是相同的，他是作为一个参数传递来被调用的.
3 这两个变量都为true时，就对sensor进行上电,然后就通过ret =g_pInvokeSensorFunc[i]->SensorOpen()进入到了模块sensor驱动中的open函数。
	至于上电跟掉电函数 kdCISModulePowerOn，在 kernel-3.18/drivers/misc/mediatek/imgsensor/src/mt6735/camera_project/xxxx/camera_hw/kd_camera_hw.c文件中，其实上电跟掉电时序就是
	配置一些GPIO口，然后在把camera的三路电压按dateshell配置一下上掉电的时间。
*/
BOOL g_bEnableDriver[KDIMGSENSOR_MAX_INVOKE_DRIVERS] = {FALSE, FALSE};
SENSOR_FUNCTION_STRUCT *g_pInvokeSensorFunc[KDIMGSENSOR_MAX_INVOKE_DRIVERS] = {NULL, NULL};

CAMERA_DUAL_CAMERA_SENSOR_ENUM g_invokeSocketIdx[KDIMGSENSOR_MAX_INVOKE_DRIVERS] = {DUAL_CAMERA_NONE_SENSOR, DUAL_CAMERA_NONE_SENSOR};


MUINT32 kd_MultiSensorOpen(void)
{
	MUINT32 ret = ERROR_NONE;
	MINT32 i = 0;

	/* 计算当前时间 */
	KD_MULTI_FUNCTION_ENTRY();

	for (i = (KDIMGSENSOR_MAX_INVOKE_DRIVERS - 1); i >= KDIMGSENSOR_INVOKE_DRIVER_0; i--) {

		/*
		1 g_bEnableDriver g_pInvokeSensorFunc[i] 这两个变量都为true时，就对sensor进行上电,然后就通过ret =g_pInvokeSensorFunc[i]->SensorOpen()进入到了模块sensor驱动中的open函数。
		2 于上电跟掉电函数 kdCISModulePowerOn，在 kernel-3.18/drivers/misc/mediatek/imgsensor/src/mt6735/camera_project/xxxx/camera_hw/kd_camera_hw.c文件中，其实上电跟掉电时序就是
			配置一些GPIO口，然后在把camera的三路电压按dateshell配置一下上掉电的时间。

		3.这里可以看出hal调用ioctl命令时不可能先走 KDIMGSENSORIOC_T_OPEN 这个命令，因为此时 g_pInvokeSensorFunc 为 NULL，还没有绑定到模组的 SENSOR_FUNCTION_STRUCT sensor_func。
		所以这里代码无法执行，由后面的代码可以看到，ioctl先走的cmd命令是 KDIMGSENSORIOC_X_SET_DRIVER，在 KDIMGSENSORIOC_X_SET_DRIVER里面对 g_pInvokeSensorFunc进行初始化。

		*/
		if (g_bEnableDriver[i] && g_pInvokeSensorFunc[i]) {
			if (0 != (g_CurrentSensorIdx & g_invokeSocketIdx[i])) {
#ifndef CONFIG_FPGA_EARLY_PORTING

				/*上电*/
				ret = kdCISModulePowerOn((CAMERA_DUAL_CAMERA_SENSOR_ENUM)g_invokeSocketIdx[i], (char *)g_invokeSensorNameStr[i], true, CAMERA_HW_DRVNAME1);
#endif
	
				/* wait for power stable 等待电源稳定*/
				mDELAY(10);

				//调用到模块驱动中的open函数，g_pInvokeSensorFunc[i]保存的值为模块驱动中的static SENSOR_FUNCTION_STRUCT sensor_func这个结构体的指针(地址)
				ret = g_pInvokeSensorFunc[i]->SensorOpen();
				if (ERROR_NONE != ret) {
#ifndef CONFIG_FPGA_EARLY_PORTING
					/*掉电*/
					kdCISModulePowerOn((CAMERA_DUAL_CAMERA_SENSOR_ENUM)g_invokeSocketIdx[i], (char *)g_invokeSensorNameStr[i], false, CAMERA_HW_DRVNAME1);
#endif
					PK_ERR("SensorOpen");
					return ret;
				}

			}
		}
	}
	KD_MULTI_FUNCTION_EXIT();
	return ERROR_NONE;
}


static inline int adopt_CAMERA_HW_Open(void)
{
	UINT32 err = 0;

	/*
	1.判断我们 imagesensor 操作函数指针是否为NULL，如果为NULL，报错，因为我们就是靠这个操作函数集合去操作imagesensor 的 
	*/
	if (g_pSensorFunc) {
		err = g_pSensorFunc->SensorOpen();// 会调用到 kd_MultiSensorFunc 里面的 kd_MultiSensorOpen 函数
	} 
} 


UINT32 kdGetSensorInitFuncList(ACDK_KD_SENSOR_INIT_FUNCTION_STRUCT **ppSensorList)
{
	/* 获取 kdSensorList[] 数组首地址  kernel-3.18/drivers/misc/mediatek/imgsensor/src/mt6735/kd_sensorlist.h  
	如：

	UINT32 GC2023MIPISensorInit(PSENSOR_FUNCTION_STRUCT *pfFunc);
	...
	ACDK_KD_SENSOR_INIT_FUNCTION_STRUCT kdSensorList[MAX_NUM_OF_SUPPORT_SENSOR+1] = {

		...

		#if defined(GC2023_MIPI_YUV)
		    {GC2023MIPI_SENSOR_ID, SENSOR_DRVNAME_GC2023_MIPI_YUV,GC2023MIPISensorInit},
		...
	}

	*/
	/*
	 kdSensorList在kd_sensorlist.h文件里面，就是保存 cameraId，cameraNmae，模块驱动人口函数的结构体
	*/
	*ppSensorList = &kdSensorList[0];
	return 0;
}



int kdSetDriver(unsigned int *pDrvIndex)
{
	/* ACDK_KD_SENSOR_INIT_FUNCTION_STRUCT *pSensorList 保存 Sensor的 ID Name Init函数信息 */
	ACDK_KD_SENSOR_INIT_FUNCTION_STRUCT *pSensorList = NULL;

	u32 drvIdx[KDIMGSENSOR_MAX_INVOKE_DRIVERS] = {0, 0};
	u32 i;


	/* Camera information */
	gDrvIndex = pDrvIndex[KDIMGSENSOR_INVOKE_DRIVER_0];

	/* 
	首先获得dSensorList[]数组首地址，将 pSensorList指针 指向 src/kd_sensorlist.h里面 
	ACDK_KD_SENSOR_INIT_FUNCTION_STRUCT kdSensorList[MAX_NUM_OF_SUPPORT_SENSOR+1] 变量的首地址。即获取初始化列表地址
	*/	
	if (0 != kdGetSensorInitFuncList(&pSensorList)) {
		PK_ERR("ERROR:kdGetSensorInitFuncList()\n");
		return -EIO;
	}

	for (i = KDIMGSENSOR_INVOKE_DRIVER_0; i < KDIMGSENSOR_MAX_INVOKE_DRIVERS; i++) {
		/*  */
		spin_lock(&kdsensor_drv_lock);

		/*
		先将 g_bEnableDriver[i]设置为 false
		*/
		g_bEnableDriver[i] = FALSE;

		// 保存camera的sensorId
		g_invokeSocketIdx[i] = (CAMERA_DUAL_CAMERA_SENSOR_ENUM)((pDrvIndex[i] & KDIMGSENSOR_DUAL_MASK_MSB) >> KDIMGSENSOR_DUAL_SHIFT);
		spin_unlock(&kdsensor_drv_lock);
		drvIdx[i] = (pDrvIndex[i] & KDIMGSENSOR_DUAL_MASK_LSB);


		if (MAX_NUM_OF_SUPPORT_SENSOR > drvIdx[i]) {
			/*
			判断模块驱动的init函数是否为NULL	
			*/
			if (NULL == pSensorList[drvIdx[i]].SensorInit) {
				PK_ERR("ERROR:kdSetDriver()\n");
				return -EIO;
			}

			/*
			传递 &g_pInvokeSensorFunc[i] 为参数,其中还是传递的地址,这就将g_pInvokeSensorFunc的首地址指向了模块驱动函数中的UINT32 GC2023MIPISensorInit(PSENSOR_FUNCTION_STRUCT *pfFunc)这个函数
			调用模块驱动中的init函数，将 g_pInvokeSensorFunc[sensor]指针指向 sensor模组的 SENSOR_FUNCTION_STRUCT。即绑定 sensor模组的 SENSOR_FUNCTION_STRUCT。
			*/
			pSensorList[drvIdx[i]].SensorInit(&g_pInvokeSensorFunc[i]);

			/*
			将 g_bEnableDrive[i] 设置为TRUE，表示与该g_bEnableDriver[i]对应的 sensor 可用。
			*/
			g_bEnableDriver[i] = TRUE;

			/* 获取Sensor Name */
			memcpy((char *)g_invokeSensorNameStr[i], (char *)pSensorList[drvIdx[i]].drvname, sizeof(pSensorList[drvIdx[i]].drvname));

		}
	}
	return 0;
}



int kdSetCurrentSensorIdx(unsigned int idx)
{
	g_CurrentSensorIdx = idx;
	return 0;
}



static long CAMERA_HW_Ioctl(struct file *a_pstFile,unsigned int a_u4Command,unsigned long a_u4Param)
{

	switch (a_u4Command) {
		//open
	case KDIMGSENSORIOC_T_OPEN:
		i4RetValue = adopt_CAMERA_HW_Open();
		break;

	case KDIMGSENSORIOC_X_SET_DRIVER:
		i4RetValue = kdSetDriver((unsigned int *)pBuff);
		break;

	case KDIMGSENSORIOC_X_SET_CURRENT_SENSOR:
		i4RetValue = kdSetCurrentSensorIdx(*pIdx);
		break;

}




static long CAMERA_HW_Ioctl_Compat(struct file *filp, unsigned int cmd, unsigned long arg)
{
   

    case KDIMGSENSORIOC_T_OPEN://开
    case KDIMGSENSORIOC_T_CLOSE:
    case KDIMGSENSORIOC_T_CHECK_IS_ALIVE:
    case KDIMGSENSORIOC_X_SET_DRIVER:
    case KDIMGSENSORIOC_X_GET_SOCKET_POS:
    case KDIMGSENSORIOC_X_SET_I2CBUS:
    case KDIMGSENSORIOC_X_RELEASE_I2C_TRIGGER_LOCK:
    case KDIMGSENSORIOC_X_SET_SHUTTER_GAIN_WAIT_DONE:
    case KDIMGSENSORIOC_X_SET_MCLK_PLL:
    case KDIMGSENSORIOC_X_SET_CURRENT_SENSOR:
    case KDIMGSENSORIOC_X_SET_GPIO:
    case KDIMGSENSORIOC_X_GET_ISP_CLK:
    return filp->f_op->unlocked_ioctl(filp, cmd, arg);

    default:
    return -ENOIOCTLCMD;
    }
}


//主摄像头字符设备 fops
static const struct file_operations g_stCAMERA_HW_fops = {
	.owner = THIS_MODULE,
	.open = CAMERA_HW_Open,
	.release = CAMERA_HW_Release,
	.unlocked_ioctl = CAMERA_HW_Ioctl,
#ifdef CONFIG_COMPAT
	.compat_ioctl = CAMERA_HW_Ioctl_Compat,
#endif

};

//副摄像头字符设备 fops
static const struct file_operations g_stCAMERA_HW_fops0 = {
	.owner = THIS_MODULE,
	.open = CAMERA_HW_Open2,
	.release = CAMERA_HW_Release2,
	.unlocked_ioctl = CAMERA_HW_Ioctl,
#ifdef CONFIG_COMPAT
	.compat_ioctl = CAMERA_HW_Ioctl_Compat,
#endif

};

kernel-3.18/drivers/misc/mediatek/imgsensor/src/mt6735/kd_sensorlist.h

	...
UINT32 GC2023MIPISensorInit(PSENSOR_FUNCTION_STRUCT *pfFunc);
	...
ACDK_KD_SENSOR_INIT_FUNCTION_STRUCT kdSensorList[MAX_NUM_OF_SUPPORT_SENSOR+1] =
{
	...
#if defined(GC2023_MIPI_YUV)
    {GC2023MIPI_SENSOR_ID, SENSOR_DRVNAME_GC2023_MIPI_YUV,GC2023MIPISensorInit},
#endif
	...
}
	...

kernel-3.18/drivers/misc/mediatek/imgsensor/inc/kd_imgsensor_define.h

typedef struct {
	MUINT32(*SensorOpen)(void);
	MUINT32(*SensorGetInfo)(MUINT32 *pScenarioId[2], MSDK_SENSOR_INFO_STRUCT * pSensorInfo[2], MSDK_SENSOR_CONFIG_STRUCT *pSensorConfigData[2]);
	MUINT32(*SensorGetResolution)(MSDK_SENSOR_RESOLUTION_INFO_STRUCT * pSensorResolution[2]);
	MUINT32(*SensorFeatureControl)(CAMERA_DUAL_CAMERA_SENSOR_ENUM InvokeCamera, MSDK_SENSOR_FEATURE_ENUM FeatureId, MUINT8 *pFeaturePara, MUINT32 *pFeatureParaLen);
	MUINT32(*SensorControl)(CAMERA_DUAL_CAMERA_SENSOR_ENUM InvokeCamera, MSDK_SCENARIO_ID_ENUM ScenarioId, MSDK_SENSOR_EXPOSURE_WINDOW_STRUCT *pImageWindow, MSDK_SENSOR_CONFIG_STRUCT *pSensorConfigData);
	MUINT32(*SensorClose)(void);
} MULTI_SENSOR_FUNCTION_STRUCT2, *PMULTI_SENSOR_FUNCTION_STRUCT2;


typedef struct {
        MUINT32(*SensorOpen)(void);
        MUINT32(*SensorGetInfo)(MSDK_SCENARIO_ID_ENUM ScenarioId, MSDK_SENSOR_INFO_STRUCT *pSensorInfo,
                                MSDK_SENSOR_CONFIG_STRUCT *pSensorConfigData);
        MUINT32(*SensorGetResolution)(MSDK_SENSOR_RESOLUTION_INFO_STRUCT *pSensorResolution);
        MUINT32(*SensorFeatureControl)(MSDK_SENSOR_FEATURE_ENUM FeatureId, MUINT8 *pFeaturePara, MUINT32 *pFeatureParaLen);
        MUINT32(*SensorControl)(MSDK_SCENARIO_ID_ENUM ScenarioId, MSDK_SENSOR_EXPOSURE_WINDOW_STRUCT *pImageWindow, MSDK_SENSOR_CONFIG_STRUCT *pSensorConfigData);
        MUINT32(*SensorClose)(void);
#if 1 /* isp suspend resume patch */
        MSDK_SCENARIO_ID_ENUM ScenarioId;
        MSDK_SENSOR_EXPOSURE_WINDOW_STRUCT imageWindow;
        MSDK_SENSOR_CONFIG_STRUCT sensorConfigData;
#endif
} SENSOR_FUNCTION_STRUCT, *PSENSOR_FUNCTION_STRUCT;


//保存 Sensor ID Name Init函数 等信息
typedef struct {
        MUINT32 SensorId;
        MUINT8 drvname[32];
        MUINT32(*SensorInit)(PSENSOR_FUNCTION_STRUCT *pfFunc);
} ACDK_KD_SENSOR_INIT_FUNCTION_STRUCT, *PACDK_KD_SENSOR_INIT_FUNCTION_STRUCT;

kernel-3.18/drivers/misc/mediatek/imgsensor/src/mt6735/camera_hw/kd_camera_hw.c

int kdCISModulePowerOn(CAMERA_DUAL_CAMERA_SENSOR_ENUM SensorIdx, char *currSensorName, bool On, char *mode_name)
{

	u32 pinSetIdx = 0;/* default main sensor */
	...

	...

	if (DUAL_CAMERA_MAIN_SENSOR == SensorIdx)
		pinSetIdx = 0;//主摄像头(后摄像头)
	else if (DUAL_CAMERA_SUB_SENSOR == SensorIdx)
		pinSetIdx = 1;//副摄像头(前摄像头)
	else if (DUAL_CAMERA_MAIN_2_SENSOR == SensorIdx)
		pinSetIdx = 2;


	//通过DriverName来区分SensorIC ...
		如： currSensorName && (0 == strcmp(SENSOR_DRVNAME_IMX258_MIPI_RAW, currSensorName)
	//上电操作 ...
}

kernel-3.18/drivers/misc/mediatek/imgsensor/src/mt6735/camera_project/xxxx/gc2023_mipi_raw/gc2023mipi_Sensor.c

static SENSOR_FUNCTION_STRUCT sensor_func = {
    open,
    get_info,
    get_resolution,
    feature_control,
    control,
    close
};

//将 GC2023驱动指针 赋值给  static SENSOR_FUNCTION_STRUCT sensor_func。同理就是后面在通用驱动中可以直接凭借pfun指针调用sensorlist中的驱动中的各个功能函数
UINT32 GC2023MIPISensorInit(PSENSOR_FUNCTION_STRUCT *pfFunc)
{
    /* To Do : Check Sensor status here */
    if (pfFunc!=NULL)
        *pfFunc=&sensor_func;
    return ERROR_NONE;
}    /*    GC2023MIPI_RAW_SensorInit    */