camer驱动模块加载分析
在平时工作中，camera模块是经常进行调试修改的模块，所以熟悉camera的工作流程以及工作原理将会大大的提供工作效率，但对于整个android系统camera是个十分复杂的模块，下面对camera的驱动加载进行分析。
1、 Camera成像简介
景物通过镜头（LENS）生成的光学图像投射到图像传感器(Sensor)表面上，然后转为模拟的电信号，经过 A/D（模数转换）转换后变为数字图像信号，再送到数字信号处理芯片（DSP）中加工处理，再通过 IO 接口传输到 CPU 中处理，通过 LCD 就可以看到图像了。
图像传感器（SENSOR）是一种半导体芯片，其表面包含有几十万到几百万的光电二极管。光电二极管受到光照射时，就会产生电荷。目前的 SENSOR 类型有两种：CCD（ChargeCouple Device)和CMOS（ComplementaryMetal Oxide Semiconductor）。CCD电荷耦合器件，它是目前高像素类 sensor 中比较成熟的成像器件，是以一行为单位的电流信号。CMOS互补金属氧化物半导体。CMOS的信号是以点为单位的电荷信号，更为敏感，速度也更快，更为省电。ISP 的性能是决定影像流畅的关键，JPEGencoder 的性能也是关键指标之一。而 JPEGencoder 又分为硬件 JPEG 压缩方式和软件 RGB压缩方式。DSP 控制芯片的作用是：将感光芯片获取的数据及时快速地传到 baseband 中并刷新感光芯片，因此控制芯片的好坏，直接决定画面品质（比如色彩饱和度、清晰度）与流畅度。
图像传感器（SENSOR）是一种半导体芯片，其表面包含有几十万到几百万的光电二极管。光电二极管受到光照射时，就会产生电荷。目前的 SENSOR 类型有两种：CCD（ChargeCouple Device)和CMOS（ComplementaryMetal Oxide Semiconductor）。CCD电荷耦合器件，它是目前高像素类 sensor 中比较成熟的成像器件，是以一行为单位的电流信号。CMOS互补金属氧化物半导体。CMOS的信号是以点为单位的电荷信号，更为敏感，速度也更快，更为省电。ISP 的性能是决定影像流畅的关键，JPEGencoder 的性能也是关键指标之一。而 JPEGencoder 又分为硬件 JPEG 压缩方式和软件 RGB压缩方式。DSP 控制芯片的作用是：将感光芯片获取的数据及时快速地传到 baseband 中并刷新感光芯片，因此控制芯片的好坏，直接决定画面品质（比如色彩饱和度、清晰度）与流畅度。
2、Camera的硬件原理图及引脚
从上面可看出，连接 Camera 的pin引脚可大致分为以下几类：
2.1、 电源部分：
a）：VCAMD 就是DVDD数字供电，主要给ISP供电，由于 RAWDATA格式的sensor其ISP是在BB端，所以将其引脚将其NC。从上面的规格书上可以看出 DVDD是内部BB端供电。模组已将其 NC掉了,在MTK代码中的上电部分，DVDD电压用CAMERA_POWER_VCAM_D表示；
b）：VCAM_IO 就是 VDDIO 数字 IO 电源主要给 I2C 部分供电，在MTK代码中的上电部分，DVDD电压用CAMERA_POWER_VCAM_D2表示；
c）：VCAMA 就是 AVDD 模拟供电，主要给感光区和 ADC 部分供电，在MTK代码中的上电部分，DVDD电压用CAMERA_POWER_VCAM_A表示；
d）：VCAM_AF 是对 Camera 自动对焦马达的供电，在MTK代码中的上电部分，DVDD电压用CAMERA_POWER_VCAM_A2表示。
2.2、 Sensor Input 部分：
a) ：Reset 信号，用于复位、初始化。
b) ：Standby/PowerDown信号，用于进入待机模式，降低功耗。
c) ：Mclk，即MasterClock 信号，是由 BB 端提供。2.3、Sensor OutPut 部分：
a) ：Pclk，即 PixelClock 信号，由 MCLK 分频得到，作为外部时钟控制图像传输帧率；
b) ：HSYNC，行同步信号，其上升沿表示新一列行图像数据的开始；
c) ：VSYNC，帧同步信号，其下降沿表示新的一帧图片的开始；
d) ：D0-D9 一共 10 根数据线（8/10 根等）。
2.4、I2C 部分：
Camera也是挂载在I2C总线上的设备，主要利用I2C总线对寄存器进行一些读写，与其他该做在I2C总线上的设备一样，这部分就两根线SCL和SDA，SCL，I2C 时钟信号线和 SDA，I2C 数据信号线。
3、Camera架构
上图的架构相信大家都有了一定的了解，android 将系统大致分为应用层、库文件和硬件抽象层、Linux 内核三层。在底层的内核空间，Camera 的 driver 将其驱动起来以后，将硬件驱动的接口交给硬件抽象层，android 上层的 Camera 应用程序在 android 实时系统中的虚拟机中，加载 android 留给 Camera 公用的一些库文件，调用硬件抽象层的接口来控制 Camera硬件来实现功能。当然，如果是 Raw 模式的 Camera，还需要在硬件抽象层调用一些参数来控制 Camera 的效果。
Kernel 部分主要有两块：一块是image sensor 驱动，负责具体型号的sensor 的id 检测，上电，以及在preview，capture,初始化，3A 等等功能设定时的寄存器配置。另一块是isp driver，通过DMA 将sensor数据流上传。
HAL层这边主要分3 块，一块是imageio，主要是数据buffer上传的pipe。一块是drv，包含imgsensor 和isp 的hal 层控制。最后是feature io，包含各种3A 等性能配置。4、Camera image sensor驱动模块驱动加载
camera模块驱动是一个字符驱动，驱动是挂载在总线上，一般在 Linux 总线驱动模型中，我们只需要关心总线、设备、驱动这三个实体。总线会充当红娘对加载于其上的设备与驱动进行配对，对于 Camera 模块也不例外，下面从总线、设备、驱动的角度来分析 Camera 模块驱动的注册、匹配与加载过程。
MTK的image_sensor注册的是一个platform类型总线驱动，首先要进行板极设备的初始化的工作，代码在：mediatek/platform/mt6572/kernel/core/mt_devs.c，里面会对platform总线注册的device进行注册：
#if 1 ///defined(CONFIG_VIDEO_CAPTURE_DRIVERS)
retval = platform_device_register(&sensor_dev);
if (retval != 0){
return retval;
}
#endif
static struct platform_device sensor_dev = {
.name = "image_sensor",
.id = -1,
};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,
}
};
/*=======================================================================
* CAMERA_HW_i2C_init()
*=======================================================================*/
static int __init CAMERA_HW_i2C_init(void)
{
struct proc_dir_entry *prEntry;
//i2c_register_board_info(CAMERA_I2C_BUSNUM, &kd_camera_dev, 1);
i2c_register_board_info(SUPPORT_I2C_BUS_NUM1, &i2c_devs1, 1); // 填充i2c的板极文件
//i2c_register_board_info(SUPPORT_I2C_BUS_NUM2, &i2c_devs2, 1);
if(platform_driver_register(&g_stCAMERA_HW_Driver)){ // 注册platform总线的driver
PK_ERR("failed to register CAMERA_HW driver\n");
return -ENODEV;
}
//if(platform_driver_register(&g_stCAMERA_HW_Driver2)){
// PK_ERR("failed to register CAMERA_HW driver\n");
// return -ENODEV;
//}
//Register proc file for main sensor register debug
prEntry = create_proc_entry("driver/camsensor", 0, NULL); //在proc下创建driver/camsensor这个节点，用于前置摄像头进行adb效果调试
if (prEntry) {
prEntry->read_proc = CAMERA_HW_DumpReg_To_Proc;
prEntry->write_proc = CAMERA_HW_Reg_Debug;
}
else {
PK_ERR("add /proc/driver/camsensor entry fail \n");
}
//Register proc file for sub sensor register debug
prEntry = create_proc_entry("driver/camsensor2", 0, NULL); //在proc下创建driver/camsensor2这个节点，用于后置摄像头进行adb效果调试
if (prEntry) {
prEntry->read_proc = CAMERA_HW_DumpReg_To_Proc;
prEntry->write_proc = CAMERA_HW_Reg_Debug2;
}
else {
PK_ERR("add /proc/driver/camsensor2 entry fail \n");
}
atomic_set(&g_CamHWOpend, 0);
//atomic_set(&g_CamHWOpend2, 0);
atomic_set(&g_CamDrvOpenCnt, 0);
//atomic_set(&g_CamDrvOpenCnt2, 0);
atomic_set(&g_CamHWOpening, 0);
return 0;
}
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,
}
};
static int CAMERA_HW_probe(struct platform_device *pdev)
{
return i2c_add_driver(&CAMERA_HW_i2c_driver);
}
struct i2c_driver CAMERA_HW_i2c_driver = {
.probe = CAMERA_HW_i2c_probe,
.remove = CAMERA_HW_i2c_remove,
.driver.name = CAMERA_HW_DRVNAME1,
.id_table = CAMERA_HW_i2c_id,
};
static int CAMERA_HW_i2c_probe(struct i2c_client *client, const struct i2c_device_id *id)
{
int i4RetValue = 0;
PK_DBG("[CAMERA_HW] Attach I2C \n");
//get sensor i2c client
spin_lock(&kdsensor_drv_lock);
g_pstI2Cclient = client; //这里是获得我们的clientdevice，并且以platform方式进行注册
//set I2C clock rate
g_pstI2Cclient->timing = 300;//200k
spin_unlock(&kdsensor_drv_lock);
//Register char driver
i4RetValue = RegisterCAMERA_HWCharDrv(); // 注册字符驱动
if(i4RetValue){
PK_ERR("[CAMERA_HW] register char device failed!\n");
return i4RetValue;
}
//spin_lock_init(&g_CamHWLock);
PK_DBG("[CAMERA_HW] Attached!! \n");
return 0;
}
inline static int RegisterCAMERA_HWCharDrv(void)
{
struct device* sensor_device = NULL;
#if CAMERA_HW_DYNAMIC_ALLOCATE_DEVNO
if( alloc_chrdev_region(&g_CAMERA_HWdevno, 0, 1,CAMERA_HW_DRVNAME1) ) // 动态分配一个字符设备
{
PK_DBG("[CAMERA SENSOR] Allocate device no failed\n");
return -EAGAIN;
}
#else
if( register_chrdev_region( g_CAMERA_HWdevno , 1 , CAMERA_HW_DRVNAME1) ) // 静态分配一个字符设备
{
PK_DBG("[CAMERA SENSOR] Register device no failed\n");
return -EAGAIN;
}
#endif
//Allocate driver
g_pCAMERA_HW_CharDrv = cdev_alloc(); // 申请一个cdev结构体
if(NULL == g_pCAMERA_HW_CharDrv)
{
unregister_chrdev_region(g_CAMERA_HWdevno, 1);
PK_DBG("[CAMERA SENSOR] Allocate mem for kobject failed\n");
return -ENOMEM;
}
//Attatch file operation.
cdev_init(g_pCAMERA_HW_CharDrv, &g_stCAMERA_HW_fops); //关联到file_operation进入字符设备
g_pCAMERA_HW_CharDrv->owner = THIS_MODULE;
//Add to system
if(cdev_add(g_pCAMERA_HW_CharDrv, g_CAMERA_HWdevno, 1)) //将我们分配的字符设备，attach上file_operation添加到system
{
PK_DBG("[mt6516_IDP] Attatch file operation failed\n");
unregister_chrdev_region(g_CAMERA_HWdevno, 1);
return -EAGAIN;
}
sensor_class = class_create(THIS_MODULE, "sensordrv"); //创建一个sensordrv类
if (IS_ERR(sensor_class)) {
int ret = PTR_ERR(sensor_class);
PK_DBG("Unable to create class, err = %d\n", ret);
return ret;
}
sensor_device = device_create(sensor_class, NULL, g_CAMERA_HWdevno, NULL, CAMERA_HW_DRVNAME1);
return 0;
}
下面来看看g_stCAMERA_HW_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
};
static int CAMERA_HW_Open(struct inode * a_pstInode, struct file * a_pstFile)
{
//reset once in multi-open
if ( atomic_read(&g_CamDrvOpenCnt) == 0) {
//default OFF state
//MUST have
//kdCISModulePowerOn(DUAL_CAMERA_MAIN_SENSOR,"",true,CAMERA_HW_DRVNAME1);
//kdCISModulePowerOn(DUAL_CAMERA_SUB_SENSOR,"",true,CAMERA_HW_DRVNAME1);
//kdCISModulePowerOn(DUAL_CAMERA_MAIN_2_SENSOR,"",true,CAMERA_HW_DRVNAME1);
//kdCISModulePowerOn(DUAL_CAMERA_MAIN_SENSOR,"",false,CAMERA_HW_DRVNAME1);
//kdCISModulePowerOn(DUAL_CAMERA_SUB_SENSOR,"",false,CAMERA_HW_DRVNAME1);
//kdCISModulePowerOn(DUAL_CAMERA_MAIN_2_SENSOR,"",false,CAMERA_HW_DRVNAME1);
}
//
atomic_inc(&g_CamDrvOpenCnt);
return 0;
}
static long CAMERA_HW_Ioctl(
struct file * a_pstFile,
unsigned int a_u4Command,
unsigned long a_u4Param
)
{
int i4RetValue = 0;
void * pBuff = NULL;
u32 *pIdx = NULL;
mutex_lock(&kdCam_Mutex);
if(_IOC_NONE == _IOC_DIR(a_u4Command)) {
}
else {
pBuff = kmalloc(_IOC_SIZE(a_u4Command),GFP_KERNEL); //申请分配一个buffer
if(NULL == pBuff) {
PK_DBG("[CAMERA SENSOR] ioctl allocate mem failed\n");
i4RetValue = -ENOMEM;
goto CAMERA_HW_Ioctl_EXIT;
}
if(_IOC_WRITE & _IOC_DIR(a_u4Command)){ //判断是否可写
//将用户传递过来的命令参数复制到内核空间，接下来我们会根据这个数据进行选择
if(copy_from_user(pBuff , (void *) a_u4Param, _IOC_SIZE(a_u4Command))) {
kfree(pBuff);
PK_DBG("[CAMERA SENSOR] ioctl copy from user failed\n");
i4RetValue = -EFAULT;
goto CAMERA_HW_Ioctl_EXIT;
}
}
}
pIdx = (u32*)pBuff;
switch(a_u4Command) {
#if 0
case KDIMGSENSORIOC_X_POWER_ON:
i4RetValue = kdModulePowerOn((CAMERA_DUAL_CAMERA_SENSOR_ENUM) *pIdx, true, CAMERA_HW_DRVNAME);
break;
case KDIMGSENSORIOC_X_POWER_OFF:
i4RetValue = kdModulePowerOn((CAMERA_DUAL_CAMERA_SENSOR_ENUM) *pIdx, false, CAMERA_HW_DRVNAME);
break;
#endif
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_GETRESOLUTION:
i4RetValue = adopt_CAMERA_HW_GetResolution(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;
default :
PK_DBG("No such command \n");
i4RetValue = -EPERM;
break;
}
if(_IOC_READ & _IOC_DIR(a_u4Command)) {
if(copy_to_user((void __user *) a_u4Param , pBuff , _IOC_SIZE(a_u4Command))) {
kfree(pBuff);
PK_DBG("[CAMERA SENSOR] ioctl copy to user failed\n");
i4RetValue = -EFAULT;
goto CAMERA_HW_Ioctl_EXIT;
}
}
kfree(pBuff);
CAMERA_HW_Ioctl_EXIT:
mutex_unlock(&kdCam_Mutex);
return i4RetValue;
}
a）：KDIMGSENSORIOC_T_OPEN命令：
case KDIMGSENSORIOC_T_OPEN:
i4RetValue = adopt_CAMERA_HW_Open();
break;
inline static int adopt_CAMERA_HW_Open(void)
{
UINT32 err = 0;
KD_IMGSENSOR_PROFILE_INIT();
if (atomic_read(&g_CamHWOpend) == 0 ) {
if (g_pSensorFunc) { //判断我们imagesensor 操作函数指针是否为NULL，如果为NULL，报错，因为我们就是靠这个操作函数集合去操作imagesensor 的
err = g_pSensorFunc->SensorOpen(); // 会调用到kd_MultiSensorFunc里面的kd_MultiSensorOpen函数
if(ERROR_NONE != err) {
PK_DBG(" ERROR:SensorOpen(), turn off power \n");
kdModulePowerOn((CAMERA_DUAL_CAMERA_SENSOR_ENUM*) g_invokeSocketIdx, g_invokeSensorNameStr, false, CAMERA_HW_DRVNAME1);
}
}
else {
PK_DBG(" ERROR:NULL g_pSensorFunc\n");
}
KD_IMGSENSOR_PROFILE("SensorOpen");
}
else {
//PK_ERR("adopt_CAMERA_HW_Open Fail, g_CamHWOpend = %d,g_CamHWOpend2 = %d\n ",atomic_read(&g_CamHWOpend),atomic_read(&g_CamHWOpend2) );
PK_ERR("adopt_CAMERA_HW_Open Fail, g_CamHWOpend = %d\n ",atomic_read(&g_CamHWOpend) );
}
if (err == 0 ) {
atomic_set(&g_CamHWOpend, 1);
//atomic_set(&g_CamHWOpend2, 1);
}
return err?-EIO:err;
} /* adopt_CAMERA_HW_Open() */
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-- ) {
if ( g_bEnableDriver[i] && g_pInvokeSensorFunc[i] ) {
// turn on power
ret = kdCISModulePowerOn((CAMERA_DUAL_CAMERA_SENSOR_ENUM)g_invokeSocketIdx[i],(char*)g_invokeSensorNameStr[i],true,CAMERA_HW_DRVNAME1);
if ( ERROR_NONE != ret ) { // 上电
PK_ERR("[%s]",__FUNCTION__);
return ret;
}
//wait for power stable
mDELAY(10);
KD_IMGSENSOR_PROFILE("kdModulePowerOn");
ret = g_pInvokeSensorFunc[i]->SensorOpen(); //调用到模块驱动中的open函数，g_pInvokeSensorFunc保存的值为模块驱动中的SENSOR_FUNCTION_STRUCT SensorFuncGC2035这个结构体
if ( ERROR_NONE != ret ) {
kdCISModulePowerOn((CAMERA_DUAL_CAMERA_SENSOR_ENUM)g_invokeSocketIdx[i],(char*)g_invokeSensorNameStr[i],false,CAMERA_HW_DRVNAME1); // 掉电
PK_ERR("SensorOpen");
return ret;
}
}
}
KD_MULTI_FUNCTION_EXIT();
return ERROR_NONE;
}
b）：KDIMGSENSORIOC_X_SET_DRIVER命令：
case KDIMGSENSORIOC_X_SET_DRIVER:
i4RetValue = kdSetDriver((unsigned int*)pBuff);
break;
int kdSetDriver(unsigned int* pDrvIndex)
{
ACDK_KD_SENSOR_INIT_FUNCTION_STRUCT *pSensorList = NULL; // 这是一个保存cameraId跟cameraName的结构体
u32 drvIdx[KDIMGSENSOR_MAX_INVOKE_DRIVERS] = {0,0};
u32 i;
PK_XLOG_INFO("pDrvIndex:0x%08x/0x%08x \n",pDrvIndex[KDIMGSENSOR_INVOKE_DRIVER_0],pDrvIndex[KDIMGSENSOR_INVOKE_DRIVER_1]);
//set driver for MAIN or SUB sensor
if (0 != kdGetSensorInitFuncList(&pSensorList)) //调用这个函数，取得所有添加的sensor的结构的首地址
{
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_invokeSocketIdx[i] = (CAMERA_DUAL_CAMERA_SENSOR_ENUM)((pDrvIndex[i] & KDIMGSENSOR_DUAL_MASK_MSB)>>KDIMGSENSOR_DUAL_SHIFT); // 保存camera的sensorId
spin_unlock(&kdsensor_drv_lock);
drvIdx[i] = (pDrvIndex[i] & KDIMGSENSOR_DUAL_MASK_LSB);
//
if ( DUAL_CAMERA_NONE_SENSOR == g_invokeSocketIdx[i] ) { continue; }
//ToDo: remove print information
PK_XLOG_INFO("[kdSetDriver] i,g_invokeSocketIdx[%d] = %d :\n",i,i,drvIdx[i]);
PK_XLOG_INFO("[kdSetDriver] i,drvIdx[%d] = %d :\n",i,i,drvIdx[i]);
//
if ( MAX_NUM_OF_SUPPORT_SENSOR > drvIdx[i] ) {
if (NULL == pSensorList[drvIdx[i]].SensorInit) {
PK_ERR("ERROR:kdSetDriver()\n");
return -EIO;
}
pSensorList[drvIdx[i]].SensorInit(&g_pInvokeSensorFunc[i]);// 调用模块驱动中的init函数，将模块驱动里面的SENSOR_FUNCTION_STRUCT SensorFuncOV2685值传递给g_pInvokeSensorFunc结构体
if (NULL == g_pInvokeSensorFunc[i]) {
PK_ERR("ERROR:NULL g_pSensorFunc[%d]\n",i);
return -EIO;
}
//
spin_lock(&kdsensor_drv_lock);
g_bEnableDriver[i] = TRUE;
g_CurrentInvokeCam = g_invokeSocketIdx[i];
spin_unlock(&kdsensor_drv_lock);
//get sensor name
memcpy((char*)g_invokeSensorNameStr[i],(char*)pSensorList[drvIdx[i]].drvname,sizeof(pSensorList[drvIdx[i]].drvname));
//return sensor ID
//pDrvIndex[0] = (unsigned int)pSensorList[drvIdx].SensorId;
PK_XLOG_INFO("[kdSetDriver] :[%d][%d][%d][%s][%d]\n",i,g_bEnableDriver[i],g_invokeSocketIdx[i],g_invokeSensorNameStr[i],sizeof(pSensorList[drvIdx[i]].drvname));
}
}
return 0;
}
UINT32 kdGetSensorInitFuncList(ACDK_KD_SENSOR_INIT_FUNCTION_STRUCT **ppSensorList)
{
if (NULL == ppSensorList)
{
PK_DBG("[kdGetSensorInitFuncList]ERROR: NULL ppSensorList\n");
return 1;
}
*ppSensorList = &kdSensorList[0]; // kdSensorList在kd_sensorlist.h文件里面，就是保存cameraId，cameraNmae，模块驱动人口函数的结构体
return 0;
}
而ioctl里面的其他几条cmd命令基本都是在获取到了g_pInvokeSensorFunc后然后调用模块驱动中的各个接口函数，例如：
case KDIMGSENSORIOC_T_OPEN:
i4RetValue = adopt_CAMERA_HW_Open();
break;
inline static int adopt_CAMERA_HW_Open(void)
{
UINT32 err = 0;
KD_IMGSENSOR_PROFILE_INIT();
//power on sensor
//if ((atomic_read(&g_CamHWOpend) == 0) && (atomic_read(&g_CamHWOpend2) == 0)) {
if (atomic_read(&g_CamHWOpend) == 0 ) {
//move into SensorOpen() for 2on1 driver
// turn on power
//kdModulePowerOn((CAMERA_DUAL_CAMERA_SENSOR_ENUM*) g_invokeSocketIdx, g_invokeSensorNameStr,true, CAMERA_HW_DRVNAME);
//wait for power stable
//mDELAY(10);
//KD_IMGSENSOR_PROFILE("kdModulePowerOn");
//
if (g_pSensorFunc) {
err = g_pSensorFunc->SensorOpen();
if(ERROR_NONE != err) {
PK_DBG(" ERROR:SensorOpen(), turn off power \n");
kdModulePowerOn((CAMERA_DUAL_CAMERA_SENSOR_ENUM*) g_invokeSocketIdx, g_invokeSensorNameStr, false, CAMERA_HW_DRVNAME1);
}
}
else {
PK_DBG(" ERROR:NULL g_pSensorFunc\n");
}
KD_IMGSENSOR_PROFILE("SensorOpen");
}
else {
//PK_ERR("adopt_CAMERA_HW_Open Fail, g_CamHWOpend = %d,g_CamHWOpend2 = %d\n ",atomic_read(&g_CamHWOpend),atomic_read(&g_CamHWOpend2) );
PK_ERR("adopt_CAMERA_HW_Open Fail, g_CamHWOpend = %d\n ",atomic_read(&g_CamHWOpend) );
}
if (err == 0 ) {
atomic_set(&g_CamHWOpend, 1);
//atomic_set(&g_CamHWOpend2, 1);
}
return err?-EIO:err;
} /* adopt_CAMERA_HW_Open() */
UINT32 GC2035_YUV_SensorInit(PSENSOR_FUNCTION_STRUCT *pfFunc)
{
/* To Do : Check Sensor status here */
if (pfFunc!=NULL)
*pfFunc=&SensorFuncGC2035;
return ERROR_NONE;
} /* Sensor
SENSOR_FUNCTION_STRUCT SensorFuncGC2035=
{
GC2035Open,
GC2035GetInfo,
GC2035GetResolution,
GC2035FeatureControl,
GC2035Control,
GC2035Close
};
GC2035Open：
UINT32 GC2035Open(void)
{
volatile signed char i;
kal_uint16 sensor_id=0;
zoom_factor = 0;
Sleep(10);
SENSORDB("GC2035Open\r\n");
// Read sensor ID to adjust I2C is OK?
for(i=0;i<3;i++)
{
sensor_id = (GC2035_read_cmos_sensor(0xf0) << 8) | GC2035_read_cmos_sensor(0xf1);
if(sensor_id != GC2035_SENSOR_ID) // GC2035_SENSOR_ID = 0x2035
{
return ERROR_SENSOR_CONNECT_FAIL;
}
}
SENSORDB("GC2035 Sensor Read ID OK \r\n");
GC2035_Sensor_Init();
GC2035_Write_More();
Preview_Shutter =GC2035_read_shutter();
return ERROR_NONE;
}
GC2035GetInfo：
UINT32 GC2035GetInfo(MSDK_SCENARIO_ID_ENUM ScenarioId,
MSDK_SENSOR_INFO_STRUCT *pSensorInfo,
MSDK_SENSOR_CONFIG_STRUCT *pSensorConfigData)
{
pSensorInfo->SensorPreviewResolutionX=GC2035_IMAGE_SENSOR_PV_WIDTH;
pSensorInfo->SensorPreviewResolutionY=GC2035_IMAGE_SENSOR_PV_HEIGHT;
pSensorInfo->SensorFullResolutionX=GC2035_IMAGE_SENSOR_FULL_WIDTH;
pSensorInfo->SensorFullResolutionY=GC2035_IMAGE_SENSOR_FULL_HEIGHT;
pSensorInfo->SensorCameraPreviewFrameRate=30;
pSensorInfo->SensorVideoFrameRate=30;
pSensorInfo->SensorStillCaptureFrameRate=10;
pSensorInfo->SensorWebCamCaptureFrameRate=15;
pSensorInfo->SensorResetActiveHigh=FALSE;
pSensorInfo->SensorResetDelayCount=1;
pSensorInfo->SensorOutputDataFormat=SENSOR_OUTPUT_FORMAT_YUYV;
pSensorInfo->SensorClockPolarity=SENSOR_CLOCK_POLARITY_LOW; /*??? */
pSensorInfo->SensorClockFallingPolarity=SENSOR_CLOCK_POLARITY_LOW;
pSensorInfo->SensorHsyncPolarity = SENSOR_CLOCK_POLARITY_LOW;
pSensorInfo->SensorVsyncPolarity = SENSOR_CLOCK_POLARITY_LOW;
pSensorInfo->SensorInterruptDelayLines = 1;
pSensorInfo->CaptureDelayFrame = 4;
pSensorInfo->PreviewDelayFrame = 1; // 2 betty
pSensorInfo->VideoDelayFrame = 0;
pSensorInfo->SensorMasterClockSwitch = 0;
pSensorInfo->SensorDrivingCurrent = ISP_DRIVING_6MA;
pSensorInfo->SensroInterfaceType=SENSOR_INTERFACE_TYPE_PARALLEL;
SENSORDB("GC2035GetInfo\r\n");
switch (ScenarioId)
{
case MSDK_SCENARIO_ID_CAMERA_PREVIEW:
case MSDK_SCENARIO_ID_VIDEO_PREVIEW:
pSensorInfo->SensorClockFreq=22;
pSensorInfo->SensorClockDividCount=3;
pSensorInfo->SensorClockRisingCount= 0;
pSensorInfo->SensorClockFallingCount= 2;
pSensorInfo->SensorPixelClockCount= 3;
pSensorInfo->SensorDataLatchCount= 2;
pSensorInfo->SensorGrabStartX = 2;
pSensorInfo->SensorGrabStartY = 2;
break;
case MSDK_SCENARIO_ID_CAMERA_CAPTURE_JPEG:
pSensorInfo->SensorClockFreq=22;
pSensorInfo->SensorClockDividCount=3;
pSensorInfo->SensorClockRisingCount= 0;
pSensorInfo->SensorClockFallingCount= 2;
pSensorInfo->SensorPixelClockCount= 3;
pSensorInfo->SensorDataLatchCount= 2;
pSensorInfo->SensorGrabStartX = 2;
pSensorInfo->SensorGrabStartY = 2;
break;
default:
pSensorInfo->SensorClockFreq=22;
pSensorInfo->SensorClockDividCount=3;
pSensorInfo->SensorClockRisingCount=0;
pSensorInfo->SensorClockFallingCount=2;
pSensorInfo->SensorPixelClockCount=3;
pSensorInfo->SensorDataLatchCount=2;
pSensorInfo->SensorGrabStartX = 2;
pSensorInfo->SensorGrabStartY = 2;
break;
}
memcpy(pSensorConfigData, &GC2035SensorConfigData, sizeof(MSDK_SENSOR_CONFIG_STRUCT));
return ERROR_NONE;
}
GC2035GetResolution：
UINT32 GC2035GetResolution(MSDK_SENSOR_RESOLUTION_INFO_STRUCT *pSensorResolution)
{
SENSORDB("GC2035GetResolution\r\n");
pSensorResolution->SensorFullWidth=GC2035_IMAGE_SENSOR_FULL_WIDTH - 2 * IMAGE_SENSOR_START_GRAB_X;
pSensorResolution->SensorFullHeight=GC2035_IMAGE_SENSOR_FULL_HEIGHT - 2 * IMAGE_SENSOR_START_GRAB_Y;
pSensorResolution->SensorPreviewWidth=GC2035_IMAGE_SENSOR_PV_WIDTH - 2 * IMAGE_SENSOR_START_GRAB_X;
pSensorResolution->SensorPreviewHeight=GC2035_IMAGE_SENSOR_PV_HEIGHT - 2 * IMAGE_SENSOR_START_GRAB_Y;
pSensorResolution->SensorVideoWidth=GC2035_IMAGE_SENSOR_PV_WIDTH - 2 * IMAGE_SENSOR_START_GRAB_X;
pSensorResolution->SensorVideoHeight=GC2035_IMAGE_SENSOR_PV_HEIGHT - 2 * IMAGE_SENSOR_START_GRAB_Y;
return ERROR_NONE;
}
GC2035FeatureControl：
UINT32 GC2035FeatureControl(MSDK_SENSOR_FEATURE_ENUM FeatureId,
UINT8 *pFeaturePara,UINT32 *pFeatureParaLen)
{
UINT16 *pFeatureReturnPara16=(UINT16 *) pFeaturePara;
UINT16 *pFeatureData16=(UINT16 *) pFeaturePara;
UINT32 *pFeatureReturnPara32=(UINT32 *) pFeaturePara;
UINT32 *pFeatureData32=(UINT32 *) pFeaturePara;
MSDK_SENSOR_CONFIG_STRUCT *pSensorConfigData=(MSDK_SENSOR_CONFIG_STRUCT *) pFeaturePara;
MSDK_SENSOR_REG_INFO_STRUCT *pSensorRegData=(MSDK_SENSOR_REG_INFO_STRUCT *) pFeaturePara;
switch (FeatureId)
{
case SENSOR_FEATURE_GET_RESOLUTION:
*pFeatureReturnPara16++=GC2035_IMAGE_SENSOR_FULL_WIDTH;
*pFeatureReturnPara16=GC2035_IMAGE_SENSOR_FULL_HEIGHT;
*pFeatureParaLen=4;
break;
case SENSOR_FEATURE_GET_PERIOD:
*pFeatureReturnPara16++=GC2035_IMAGE_SENSOR_PV_WIDTH;
*pFeatureReturnPara16=GC2035_IMAGE_SENSOR_PV_HEIGHT;
*pFeatureParaLen=4;
break;
case SENSOR_FEATURE_GET_PIXEL_CLOCK_FREQ:
//*pFeatureReturnPara32 = GC2035_sensor_pclk/10;
*pFeatureParaLen=4;
break;
case SENSOR_FEATURE_SET_ESHUTTER:
break;
case SENSOR_FEATURE_SET_NIGHTMODE:
GC2035_night_mode((BOOL) *pFeatureData16);
break;
case SENSOR_FEATURE_SET_GAIN:
case SENSOR_FEATURE_SET_FLASHLIGHT:
break;
case SENSOR_FEATURE_SET_ISP_MASTER_CLOCK_FREQ:
GC2035_isp_master_clock=*pFeatureData32;
break;
case SENSOR_FEATURE_SET_REGISTER:
GC2035_write_cmos_sensor(pSensorRegData->RegAddr, pSensorRegData->RegData);
break;
case SENSOR_FEATURE_GET_REGISTER:
pSensorRegData->RegData = GC2035_read_cmos_sensor(pSensorRegData->RegAddr);
break;
case SENSOR_FEATURE_GET_CONFIG_PARA:
memcpy(pSensorConfigData, &GC2035SensorConfigData, sizeof(MSDK_SENSOR_CONFIG_STRUCT));
*pFeatureParaLen=sizeof(MSDK_SENSOR_CONFIG_STRUCT);
break;
case SENSOR_FEATURE_SET_CCT_REGISTER:
case SENSOR_FEATURE_GET_CCT_REGISTER:
case SENSOR_FEATURE_SET_ENG_REGISTER:
case SENSOR_FEATURE_GET_ENG_REGISTER:
case SENSOR_FEATURE_GET_REGISTER_DEFAULT:
case SENSOR_FEATURE_CAMERA_PARA_TO_SENSOR:
case SENSOR_FEATURE_SENSOR_TO_CAMERA_PARA:
case SENSOR_FEATURE_GET_GROUP_INFO:
case SENSOR_FEATURE_GET_ITEM_INFO:
case SENSOR_FEATURE_SET_ITEM_INFO:
case SENSOR_FEATURE_GET_ENG_INFO:
break;
case SENSOR_FEATURE_GET_GROUP_COUNT:
*pFeatureReturnPara32++=0;
*pFeatureParaLen=4;
break;
case SENSOR_FEATURE_GET_LENS_DRIVER_ID:
// get the lens driver ID from EEPROM or just return LENS_DRIVER_ID_DO_NOT_CARE
// if EEPROM does not exist in camera module.
*pFeatureReturnPara32=LENS_DRIVER_ID_DO_NOT_CARE;
*pFeatureParaLen=4;
break;
case SENSOR_FEATURE_CHECK_SENSOR_ID:
GC2035_GetSensorID(pFeatureData32);
break;
case SENSOR_FEATURE_SET_YUV_CMD:
//printk("GC2035 YUV sensor Setting:%d, %d \n", *pFeatureData32, *(pFeatureData32+1));
GC2035YUVSensorSetting((FEATURE_ID)*pFeatureData32, *(pFeatureData32+1));
break;
case SENSOR_FEATURE_SET_VIDEO_MODE:
GC2035YUVSetVideoMode(*pFeatureData16);
break;
default:
break;
}
return ERROR_NONE;
}
GC2035Control：
UINT32 GC2035Control(MSDK_SCENARIO_ID_ENUM ScenarioId, MSDK_SENSOR_EXPOSURE_WINDOW_STRUCT *pImageWindow,
MSDK_SENSOR_CONFIG_STRUCT *pSensorConfigData)
{
switch (ScenarioId)
{
case MSDK_SCENARIO_ID_CAMERA_PREVIEW:
case MSDK_SCENARIO_ID_VIDEO_PREVIEW:
GC2035_sensor_cap_zsd = KAL_FALSE;
GC2035Preview(pImageWindow, pSensorConfigData);
break;
case MSDK_SCENARIO_ID_CAMERA_CAPTURE_JPEG:
GC2035_sensor_cap_zsd = KAL_FALSE;
GC2035Capture(pImageWindow, pSensorConfigData);
break;
case MSDK_SCENARIO_ID_CAMERA_ZSD:
GC2035_sensor_cap_zsd = KAL_TRUE;
GC2035Capture(pImageWindow, pSensorConfigData);
break;
default:
break;
}
return TRUE;
}
GC2035Close：
UINT32 GC2035Close(void)
{
// CISModulePowerOn(FALSE);
SENSORDB("GC2035Close\r\n");
return ERROR_NONE;
}
到这来MTK的camera驱动的加载就结束了，但这只是在整个android中对camera架构中最基础的一些分析，android系统中camera还有很多十分复杂的东西，例如ISP，上层图像的形成，camera数据的传输等等。