v4L2 soc-camera 分析 - soc_camera.c

soc_camera.c

[cpp] view plaincopy

1455 static struct platform_driver __refdata soc_camera_pdrv = {

1456 .remove = __devexit_p(soc_camera_pdrv_remove),

1457 .driver = {

1458 .name = "soc-camera-pdrv",

1459 .owner = THIS_MODULE,

1460 },

1461 };

1462

1463 static int __init soc_camera_init(void)

1464 {

1465 int ret = bus_register(&soc_camera_bus_type);

1466 if (ret)

1467 return ret;

1468 ret = driver_register(&ic_drv);

1469 if (ret)

1470 goto edrvr;

1471

1472 ret = platform_driver_probe(&soc_camera_pdrv, soc_camera_pdrv_probe);

1473 if (ret)

1474 goto epdr;

1475

1476 return 0;

1477

1478 epdr:

1479 driver_unregister(&ic_drv);

1480 edrvr:

1481 bus_unregister(&soc_camera_bus_type);

1482 return ret;

1483 }

1472

platform_driver_probe和platform_driver_register的区别：前者功能上和
platform_driver_register是一样的，但是在内核启动完成后，这个函数就不能再执行了，这样可以释放函数
soc_camera_pdrv_probe所占的空间。

soc_camera_pdrv_probe会probe系统内名称为"soc-camera-pdrv"的平台设备，系统内有几个这样的平台设备，那么就会创建几个soc_camera_device。这些平台设备可如下定义：

[cpp] view plaincopy

struct platform_device your_mach_cameras[] = {

{

.name = "soc-camera-pdrv",

.id = 0,

.dev = {

.platform_data = adv7180_link,

},

}, {

.name = "soc-camera-pdrv",

.id = 1,

.dev = {

.platform_data = tw9912_link,

},

}

};

注意，这里假定系统的camera处理模块，接了两个camera sensor， adv7180_link和tw9912_link

[cpp] view plaincopy

static struct i2c_board_info decoder_i2c_adv7180 = {

I2C_BOARD_INFO("adv7180", (0x42 >> 1)),

};

struct soc_camera_link adv7180_link = {

.bus_id = 0,

.board_info = &decoder_i2c_adv7180,

.i2c_adapter_id = 0,

};

soc_camera_link主要用来定义i2c地址，如果sensor不是通过i2c连接到host上，那么要定义add_device和del_device函数

1465 注册一条新的总线soc-camera，这样在scan_add_host中调用device_register时，就会把这个设备挂到这个总线上。

[cpp] view plaincopy

1135 struct bus_type soc_camera_bus_type = {

1136 .name = "soc-camera",

1137 .probe = soc_camera_probe,

1138 .remove = soc_camera_remove,

1139 .suspend = soc_camera_suspend,

1140 .resume = soc_camera_resume,

1141 };

1142 EXPORT_SYMBOL_GPL(soc_camera_bus_type);

当一个soc-camera-device设备通过device_register注册设备时，就会调用soc_camera_probe函数

[cpp] view plaincopy

1402 static int __devinit soc_camera_pdrv_probe(struct platform_device *pdev)

1403 {

1404 struct soc_camera_link *icl = pdev->dev.platform_data;

1405 struct soc_camera_device *icd;

1406 int ret;

1407

1408 if (!icl)

1409 return -EINVAL;

1410

1411 icd = kzalloc(sizeof(*icd), GFP_KERNEL);

1412 if (!icd)

1413 return -ENOMEM;

1414

1415 icd->iface = icl->bus_id;

1416 icd->pdev = &pdev->dev;

1417 platform_set_drvdata(pdev, icd);

1418

1419 ret = soc_camera_device_register(icd);

1420 if (ret < 0)

1421 goto escdevreg;

1422

1423 soc_camera_device_init(&icd->dev, icl);

1424

1425 icd->user_width = DEFAULT_WIDTH;

1426 icd->user_height = DEFAULT_HEIGHT;

1427

1428 return 0;

1429

1430 escdevreg:

1431 kfree(icd);

1432

1433 return ret;

1434 }

查找匹配名为soc-camera-pdrv的platform device时，调用该函数。

1419 调用soc_camera_device_register，把这个soc_camera_device加到全局camera device链表@devices上，并且为它分配设备号，做一些必要的初始化

1423 设置soc_came_device对应device的bus为soc_camera_bus_type，这样当我们注册设备时，就会调用soc_camera_probe

[cpp] view plaincopy

1374 /*

1375 * Called from soc_camera_probe() above (with .video_lock held???)

1376 */

1377 static int soc_camera_video_start(struct soc_camera_device *icd)

1378 {

1379 struct device_type *type = icd->vdev->dev.type;

1380 int ret;

1381

1382 if (!icd->dev.parent)

1383 return -ENODEV;

1384

1385 if (!icd->ops ||

1386 !icd->ops->query_bus_param ||

1387 !icd->ops->set_bus_param)

1388 return -EINVAL;

1389

1390 ret = video_register_device(icd->vdev, VFL_TYPE_GRABBER, -1);

1391 if (ret < 0) {

1392 dev_err(&icd->dev, "video_register_device failed: %d\n", ret);

1393 return ret;

1394 }

1395

1396 /* Restore device type, possibly set by the subdevice driver */

1397 icd->vdev->dev.type = type;

1398

1399 return 0;

1400 }

在当前的上下文，soc_camera_video_start的调用路径如下

soc_camera_host_register ==> scan_add_host ==> device_register
==> bus_probe_device ==> soc_camera_bus_type.probe ==>
soc_camera_video_start

1390 我们可以看出，系统为每一个soc-camera-device创建了一个video device设备节点

[cpp] view plaincopy

1352 static int video_dev_create(struct soc_camera_device *icd)

1353 {

1354 struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);

1355 struct video_device *vdev = video_device_alloc();

1356

1357 if (!vdev)

1358 return -ENOMEM;

1359

1360 strlcpy(vdev->name, ici->drv_name, sizeof(vdev->name));

1361

1362 vdev->parent = &icd->dev;

1363 vdev->current_norm = V4L2_STD_UNKNOWN;

1364 vdev->fops = &soc_camera_fops;

1365 vdev->ioctl_ops = &soc_camera_ioctl_ops;

1366 vdev->release = video_device_release;

1367 vdev->tvnorms = V4L2_STD_UNKNOWN;

1368

1369 icd->vdev = vdev;

1370

1371 return 0;

1372 }

当前的上下文，video_dev_create的调用路径如下

soc_camera_host_register ==> scan_add_host ==> device_register
==> bus_probe_device ==> soc_camera_bus_type.probe ==>
soc_camera_video_start

这里面设置了video_device的两个非常重要的参数：soc_camera_ioctl_ops和soc_camera_fops，当user space打开video device后，所有可执行的操作，都是通过这两个入口进行的，下面是他们的定义。

[cpp] view plaincopy

549 static struct v4l2_file_operations soc_camera_fops = {

550 .owner = THIS_MODULE,

551 .open = soc_camera_open,

552 .release = soc_camera_close,

553 .unlocked_ioctl = video_ioctl2,

554 .read = soc_camera_read,

555 .mmap = soc_camera_mmap,

556 .poll = soc_camera_poll,

557 };

[cpp] view plaincopy

1321 static const struct v4l2_ioctl_ops soc_camera_ioctl_ops = {

1322 .vidioc_querycap = soc_camera_querycap,

1323 .vidioc_g_fmt_vid_cap = soc_camera_g_fmt_vid_cap,

1324 .vidioc_enum_fmt_vid_cap = soc_camera_enum_fmt_vid_cap,

1325 .vidioc_s_fmt_vid_cap = soc_camera_s_fmt_vid_cap,

1326 .vidioc_enum_input = soc_camera_enum_input,

1327 .vidioc_g_input = soc_camera_g_input,

1328 .vidioc_s_input = soc_camera_s_input,

1329 .vidioc_s_std = soc_camera_s_std,

1330 .vidioc_reqbufs = soc_camera_reqbufs,

1331 .vidioc_try_fmt_vid_cap = soc_camera_try_fmt_vid_cap,

1332 .vidioc_querybuf = soc_camera_querybuf,

1333 .vidioc_qbuf = soc_camera_qbuf,

1334 .vidioc_dqbuf = soc_camera_dqbuf,

1335 .vidioc_streamon = soc_camera_streamon,

1336 .vidioc_streamoff = soc_camera_streamoff,

1337 .vidioc_queryctrl = soc_camera_queryctrl,

1338 .vidioc_g_ctrl = soc_camera_g_ctrl,

1339 .vidioc_s_ctrl = soc_camera_s_ctrl,

1340 .vidioc_cropcap = soc_camera_cropcap,

1341 .vidioc_g_crop = soc_camera_g_crop,

1342 .vidioc_s_crop = soc_camera_s_crop,

1343 .vidioc_g_parm = soc_camera_g_parm,

1344 .vidioc_s_parm = soc_camera_s_parm,

1345 .vidioc_g_chip_ident = soc_camera_g_chip_ident,

1346 #ifdef CONFIG_VIDEO_ADV_DEBUG

1347 .vidioc_g_register = soc_camera_g_register,

1348 .vidioc_s_register = soc_camera_s_register,

1349 #endif

1350 };

soc_camera_ops 不支持read操作，因此如果使用了soc
camera子系统，那么应用层就无法再使用read操作获取camera
数据，而只能选择使用mmap方式。不支持read操作没什么关系，大部分camera操作都是使用mmap方式进行的。samsung的s5pv210
不支持read操作，而freescale mxc系列则支持read操作获取camera数据。

soc_camera_ioctl_ops也仅仅支持了v4l2_ioctl_ops的一个子集，这就意味着应用程序的作者需要考虑ioctl可能没有被支持。

[cpp] view plaincopy

1281 /* Image capture device */

1282 static int soc_camera_device_register(struct soc_camera_device *icd)

1283 {

1284 struct soc_camera_device *ix;

1285 int num = -1, i;

1286

1287 for (i = 0; i < 256 && num < 0; i++) {

1288 num = i;

1289 /* Check if this index is available on this interface */

1290 list_for_each_entry(ix, &devices, list) {

1291 if (ix->iface == icd->iface && ix->devnum == i) {

1292 num = -1;

1293 break;

1294 }

1295 }

1296 }

1297

1298 if (num < 0)

1299 /*

1300 * ok, we have 256 cameras on this host...

1301 * man, stay reasonable...

1302 */

1303 return -ENOMEM;

1304

1305 icd->devnum = num;

1306 icd->use_count = 0;

1307 icd->host_priv = NULL;

1308 mutex_init(&icd->video_lock);

1309

1310 list_add_tail(&icd->list, &devices);

1311

1312 return 0;

1313 }

把给定的@icd加到全局soc camera device列表中

1290～1294 @devices是一个全局soc camera device列表，这段代码相当拗口，注意1293行是break 1290这个循环

[cpp] view plaincopy

1194 int soc_camera_host_register(struct soc_camera_host *ici)

1195 {

1196 struct soc_camera_host *ix;

1197 int ret;

1198

1199 if (!ici || !ici->ops ||

1200 !ici->ops->try_fmt ||

1201 !ici->ops->set_fmt ||

1202 !ici->ops->set_bus_param ||

1203 !ici->ops->querycap ||

1204 !ici->ops->init_videobuf ||

1205 !ici->ops->reqbufs ||

1206 !ici->ops->add ||

1207 !ici->ops->remove ||

1208 !ici->ops->poll ||

1209 !ici->v4l2_dev.dev)

1210 return -EINVAL;

1211

1212 if (!ici->ops->set_crop)

1213 ici->ops->set_crop = default_s_crop;

1214 if (!ici->ops->get_crop)

1215 ici->ops->get_crop = default_g_crop;

1216 if (!ici->ops->cropcap)

1217 ici->ops->cropcap = default_cropcap;

1218 if (!ici->ops->set_parm)

1219 ici->ops->set_parm = default_s_parm;

1220 if (!ici->ops->get_parm)

1221 ici->ops->get_parm = default_g_parm;

1222

1223 mutex_lock(&list_lock);

1224 list_for_each_entry(ix, &hosts, list) {

1225 if (ix->nr == ici->nr) {

1226 ret = -EBUSY;

1227 goto edevreg;

1228 }

1229 }

1230

1231 ret = v4l2_device_register(ici->v4l2_dev.dev, &ici->v4l2_dev);

1232 if (ret < 0)

1233 goto edevreg;

1234

1235 list_add_tail(&ici->list, &hosts);

1236 mutex_unlock(&list_lock);

1237

1238 scan_add_host(ici);

1239

1240 return 0;

1241

1242 edevreg:

1243 mutex_unlock(&list_lock);

1244 return ret;

1245 }

1246 EXPORT_SYMBOL(soc_camera_host_register);

1231 每个camera host对应一个v4l2 device(注意不是video device)，host上device对应的才是video device

1235 @host是一个全局camera host 链表

1238 scan_add_host 关联系统内属于这个host的video device

[cpp] view plaincopy

1135 struct bus_type soc_camera_bus_type = {

1136 .name = "soc-camera",

1137 .probe = soc_camera_probe,

1138 .remove = soc_camera_remove,

1139 .suspend = soc_camera_suspend,

1140 .resume = soc_camera_resume,

1141 };

1142 EXPORT_SYMBOL_GPL(soc_camera_bus_type);

soc camera总线代码，当调用device_register注册一个新设备时，会调用probe函数

[cpp] view plaincopy

947 static int soc_camera_probe(struct device *dev)

948 {

949 struct soc_camera_device *icd = to_soc_camera_dev(dev);

950 struct soc_camera_host *ici = to_soc_camera_host(dev->parent);

951 struct soc_camera_link *icl = to_soc_camera_link(icd);

952 struct device *control = NULL;

953 struct v4l2_subdev *sd;

954 struct v4l2_mbus_framefmt mf;

955 int ret;

956

957 dev_info(dev, "Probing %s\n", dev_name(dev));

958

959 ret = regulator_bulk_get(icd->pdev, icl->num_regulators,

960 icl->regulators);

961 if (ret < 0)

962 goto ereg;

963

964 ret = soc_camera_power_set(icd, icl, 1);

965 if (ret < 0)

966 goto epower;

967

968 /* The camera could have been already on, try to reset */

969 if (icl->reset)

970 icl->reset(icd->pdev);

971

972 ret = ici->ops->add(icd);

973 if (ret < 0)

974 goto eadd;

975

976 /* Must have icd->vdev before registering the device */

977 ret = video_dev_create(icd);

978 if (ret < 0)

979 goto evdc;

980

981 /* Non-i2c cameras, e.g., soc_camera_platform, have no board_info */

982 if (icl->board_info) {

983 ret = soc_camera_init_i2c(icd, icl);

984 if (ret < 0) {

985 goto eadddev;

986 }

987 } else if (!icl->add_device || !icl->del_device) {

988 ret = -EINVAL;

989 goto eadddev;

990 } else {

991 if (icl->module_name)

992 ret = request_module(icl->module_name);

993

994 ret = icl->add_device(icl, &icd->dev);

995 if (ret < 0)

996 goto eadddev;

997

998 /*

999 * FIXME: this is racy, have to use driver-binding notification,

1000 * when it is available

1001 */

1002 control = to_soc_camera_control(icd);

1003 if (!control || !control->driver || !dev_get_drvdata(control) ||

1004 !try_module_get(control->driver->owner)) {

1005 icl->del_device(icl);

1006 goto enodrv;

1007 }

1008 }

1009

1010 /* At this point client .probe() should have run already */

1011 ret = soc_camera_init_user_formats(icd);

1012 if (ret < 0)

1013 goto eiufmt;

1014

1015 icd->field = V4L2_FIELD_ANY;

1016

1017 icd->vdev->lock = &icd->video_lock;

1018

1019 /*

1020 * ..._video_start() will create a device node, video_register_device()

1021 * itself is protected against concurrent open() calls, but we also have

1022 * to protect our data.

1023 */

1024 mutex_lock(&icd->video_lock);

1025

1026 ret = soc_camera_video_start(icd);

1027 if (ret < 0)

1028 goto evidstart;

1029

1030 /* Try to improve our guess of a reasonable window format */

1031 sd = soc_camera_to_subdev(icd);

1032 if (!v4l2_subdev_call(sd, video, g_mbus_fmt, &mf)) {

1033 icd->user_width = mf.width;

1034 icd->user_height = mf.height;

1035 icd->colorspace = mf.colorspace;

1036 icd->field = mf.field;

1037 }

1038

1039 /* Do we have to sysfs_remove_link() before device_unregister()? */

1040 if (sysfs_create_link(&icd->dev.kobj, &to_soc_camera_control(icd)->kobj,

1041 "control"))

1042 dev_warn(&icd->dev, "Failed creating the control symlink\n");

1043

1044 ici->ops->remove(icd);

1045

1046 soc_camera_power_set(icd, icl, 0);

1047

1048 mutex_unlock(&icd->video_lock);

1049

1050 return 0;

1051

1052 evidstart:

1053 mutex_unlock(&icd->video_lock);

1054 soc_camera_free_user_formats(icd);

1055 eiufmt:

1056 if (icl->board_info) {

1057 soc_camera_free_i2c(icd);

1058 } else {

1059 icl->del_device(icl);

1060 module_put(control->driver->owner);

1061 }

1062 enodrv:

1063 eadddev:

1064 video_device_release(icd->vdev);

1065 evdc:

1066 ici->ops->remove(icd);

1067 eadd:

1068 soc_camera_power_set(icd, icl, 0);

1069 epower:

1070 regulator_bulk_free(icl->num_regulators, icl->regulators);

1071 ereg:

1072 return ret;

1073 }

在host-driver probe函数中调用，soc_camera_host_register ==> scan_add_host
==> device_register ==> bus_probe_device ==> soc_camera_probe

972 调用camera host驱动的add函数，比如pxa平台的pxa_camera_add_device

977 在调用video_device_register之前，要先创建video_device

982~1008 如果是i2c
camera，那么调用soc_camera_init_i2c来初始华i2c，否则就调用add_device增加设备。
soc_camera_init_i2c会调用到芯片驱动i2c_driver.probe，对于我们的项目，则是adv7180_probe

1010~1013 初始化client format，调用soc_camera_init_user_format之前，已经执行了芯片的probe函数，已经可以对芯片进一步的操作。

1026 调用soc_camera_video_start注册一个video device

1031 每一个soc camera device都一一对应一个v4l2 subdev

1044 ~ 1046 已经获取了soc camera device必要的信息后，调用remove_device关闭soc camera device，然后调用soc_camera_power_set关闭soc camera device的电源。

[cpp] view plaincopy

869 /* So far this function cannot fail */

870 static void scan_add_host(struct soc_camera_host *ici)

871 {

872 struct soc_camera_device *icd;

873

874 mutex_lock(&list_lock);

875

876 list_for_each_entry(icd, &devices, list) {

877 if (icd->iface == ici->nr) {

878 int ret;

879 icd->dev.parent = ici->v4l2_dev.dev;

880 dev_set_name(&icd->dev, "%u-%u", icd->iface,

881 icd->devnum);

882 ret = device_register(&icd->dev);

883 if (ret < 0) {

884 icd->dev.parent = NULL;

885 dev_err(&icd->dev,

886 "Cannot register device: %d\n", ret);

887 }

888 }

889 }

890

891 mutex_unlock(&list_lock);

892 }

这个函数只被soc_camera_host_register调用。扫描系统所有的camera device，把属于这个camera host(参数@ici指定)的所有camera device注册到系统中。

876 系统所有的camera device，在没有被camera host注册前，这些camera device仅保存在@devices链表中

877 比较camera device的host number是否等于这个camera host

882 device_register
注册一个设备到系统中，这个函数会调用bus_probe_device，而bus_probe_device则会调用
soc_camera_bus_type.probe，也就是soc_camera_probe。这样soc_camera_host_register
就会注册所有属于这个host的camera
device到系统中，并且创建了相应的设备节点/dev/videoX，整个设备的注册过程全部结束了，从现在开始，可以在设备节点/dev
/videoX上调用open read
write ioctl以及poll。

[cpp] view plaincopy

178 static int soc_camera_s_input(struct file *file, void *priv, unsigned int i)

179 {

180 int ret;

181 struct soc_camera_device *icd = file->private_data;

182 struct v4l2_subdev *sd = soc_camera_to_subdev(icd);

183

184 /* call s_routing to select the input of camera sensor */

185 ret = v4l2_subdev_call(sd, video, s_routing, i, 0, 0);

186

187 return ret;

188 }

185 soc_camera驱动并没有实现这句话，而是直接 return 0，这就导致当前的soc camera子系统不支持S_INPUT接口。

[cpp] view plaincopy

384 static int soc_camera_open(struct file *file)

385 {

386 struct video_device *vdev = video_devdata(file);

387 struct soc_camera_device *icd = container_of(vdev->parent,

388 struct soc_camera_device,

389 dev);

390 struct soc_camera_link *icl = to_soc_camera_link(icd);

391 struct soc_camera_host *ici;

392 int ret;

393

394 if (!icd->ops)

395 /* No device driver attached */

396 return -ENODEV;

397

398 ici = to_soc_camera_host(icd->dev.parent);

399

400 if (!try_module_get(ici->ops->owner)) {

401 dev_err(&icd->dev, "Couldn't lock capture bus driver.\n");

402 return -EINVAL;

403 }

404

405 icd->use_count++;

406

407 /* Now we really have to activate the camera */

408 if (icd->use_count == 1) {

409 /* Restore parameters before the last close() per V4L2 API */

410 struct v4l2_format f = {

411 .type = V4L2_BUF_TYPE_VIDEO_CAPTURE,

412 .fmt.pix = {

413 .width = icd->user_width,

414 .height = icd->user_height,

415 .field = icd->field,

416 .colorspace = icd->colorspace,

417 .pixelformat =

418 icd->current_fmt->host_fmt->fourcc,

419 },

420 };

421

422 ret = soc_camera_power_set(icd, icl, 1);

423 if (ret < 0)

424 goto epower;

425

426 /* The camera could have been already on, try to reset */

427 if (icl->reset)

428 icl->reset(icd->pdev);

429

430 ret = ici->ops->add(icd);

431 if (ret < 0) {

432 dev_err(&icd->dev, "Couldn't activate the camera: %d\n", ret);

433 goto eiciadd;

434 }

435

436 pm_runtime_enable(&icd->vdev->dev);

437 ret = pm_runtime_resume(&icd->vdev->dev);

438 if (ret < 0 && ret != -ENOSYS)

439 goto eresume;

440

441 /*

442 * Try to configure with default parameters. Notice: this is the

443 * very first open, so, we cannot race against other calls,

444 * apart from someone else calling open() simultaneously, but

445 * .video_lock is protecting us against it.

446 */

447 ret = soc_camera_set_fmt(icd, &f);

448 if (ret < 0)

449 goto esfmt;

450

451 ici->ops->init_videobuf(&icd->vb_vidq, icd);

452 }

453

454 file->private_data = icd;

455 dev_dbg(&icd->dev, "camera device open\n");

456

457 return 0;

458

459 /*

460 * First four errors are entered with the .video_lock held

461 * and use_count == 1

462 */

463 esfmt:

464 pm_runtime_disable(&icd->vdev->dev);

465 eresume:

466 ici->ops->remove(icd);

467 eiciadd:

468 soc_camera_power_set(icd, icl, 0);

469 epower:

470 icd->use_count--;

471 module_put(ici->ops->owner);

472

473 return ret;

474 }

当应用通过open系统调用，打开设备节点/dev/videoX时，会调用soc_camera_open

430 ici->ops->add 不仅要执行host内部的初始化，还会调用camera sensor(参数icd指定)的init

447 配置camera sensor缺省的格式参数，从我个人理解，一切合理的fmt都应该在调用S_INPUT之后进行设置。当然，这需要应用程序编程时先调用S_INPUT再进行S_FMT。

405~408 仅在第一次打开时，才对camera host和camera sensor做初始化操作，否则，仅仅增加引用计数。