1Chinese translated version of Documentation/video4linux/v4l2-framework.txt 2 3If you have any comment or update to the content, please contact the 4original document maintainer directly. However, if you have a problem 5communicating in English you can also ask the Chinese maintainer for 6help. Contact the Chinese maintainer if this translation is outdated 7or if there is a problem with the translation. 8 9Maintainer: Mauro Carvalho Chehab <mchehab@infradead.org> 10Chinese maintainer: Fu Wei <tekkamanninja@gmail.com> 11--------------------------------------------------------------------- 12Documentation/video4linux/v4l2-framework.txt ��������������� 13 14������������������������������������������������������������������������������������������������������ 15������������������������������������������������������������������������������������������������������ 16������������������������������������������������ 17��������������������� Mauro Carvalho Chehab <mchehab@infradead.org> 18��������������������� ������ Fu Wei <tekkamanninja@gmail.com> 19��������������������� ������ Fu Wei <tekkamanninja@gmail.com> 20��������������������� ������ Fu Wei <tekkamanninja@gmail.com> 21 22 23��������������� 24--------------------------------------------------------------------- 25V4L2 ������������������ 26============== 27 28��������������� V4L2 ��������������������������������������������������������� 29 30 31������ 32---- 33 34��������������� V4L2 ��������������� IC ������������ /dev ������������������������������ 35������������������ V4L2 ������������ DVB���ALSA���FB���I2C ��������������������������� 36���������������������������������V4L2 ������������������������������ 37 38��������� V4L2 ������������ IC ������������������������������������������������������������������ 39������������������������ IC ��������������������� I2C ������������������������������������������ 40��������������������������������������������������������� 41 42������������������������������������������ video_device ��������������� V4L ��������������� 43��������� video_buf ������������������������������������������ video_buf ������������ 44 45��������������������������������������������������������������������������������������������������������� 46������������������������������������������������������������������������ 47 48��������������������������������������������������������������������� 49 50��������������������������������������������������������������������������������������������������������� 51��������������������������������������������������������������������� 52 53 54������������ 55------- 56 57������ V4L2 ��������������������������� 58 591) ������������������������������--������������������������ 60 612) ������������������������������������������������������ 62 633) ������ V4L2 ������������ (/dev/videoX���/dev/vbiX ��� /dev/radioX) 64 ��������������������������������������� 65 664) ���������������������������--������������������������������������ 67 685) ��������������������� 69 70������������������������������������ 71 72 device instances������������������ 73 | 74 +-sub-device instances��������������������� 75 | 76 \-V4L2 device nodes���V4L2 ��������������� 77 | 78 \-filehandle instances������������������������ 79 80 81������������ 82------- 83 84������������������������������������������������ v4l2_device ������������������������ 85������������������������ v4l2_subdev ���������������������������������video_device 86��������������� V4L2 ������������������������������ v4l2_fh ������������������������������ 87��������������������������������� 88 89V4L2 ������������������������������������������������������������������������ v4l2_device 90������������ mdev ��������������������������������������������������������������������������� 91 92 93v4l2_device ��������� 94---------------- 95 96��������������������������� v4l2_device (v4l2-device.h)��������������������� 97������������������������������������������������������������������������������������������������ 98��������������������������������������� 99 100������������������������������������ 101 102 v4l2_device_register(struct device *dev, struct v4l2_device *v4l2_dev); 103 104��������������������������� v4l2_device ������������������ dev->driver_data ��� 105��� NULL������������������ v4l2_dev��� 106 107������������������������������������������������������ dev->driver_data��������������� 108v4l2_device ������������������������������������������������������������������ V4L2 ������ 109��������������� dev_set_drvdata() ��������������������������������� v4l2_device 110������������ mdev ��������������������������������������������� media_device ��������� 111 112������ v4l2_dev->name ��������������������������������� dev ��������������������������� 113��������������������������������������� bus_id������������������������ v4l2_device_register 114��������������������������������������������������� dev ��� NULL���������*������*��������� 115v4l2_device_register ��������� v4l2_dev->name��� 116 117������������������������������������������ atomic_t ������������������������������ 118v4l2_device_set_name() ������ name������������������������ ivtv0���ivtv1 ��� 119��������������������������������������������������������������������������������������������������� 120cx18-0���cx18-1 ������������������������������������ 121 122��������� ���dev��� ��������������������������� pci_dev���usb_interface ��� 123platform_device ��������������������������� NULL������������������ISA������������ 124������������������������������ PCI ��������������� v4l2_dev ��������������������������������� 125��������� 126 127������������������������ notify() ��������������������������������������������������������� 128��������������������������������������������������������������������������� 129include/media/<subdevice>.h ��������������������������� 130 131������ v4l2_device ��������������������� 132 133 v4l2_device_unregister(struct v4l2_device *v4l2_dev); 134 135������ dev->driver_data ��������� v4l2_dev��������������������� NULL��������������� 136��������������������������������������������� 137 138���������������������������������������USB��������������������������������������������������������� 139������ v4l2_device ������������������������������������������������������������������������ 140��������������������������������������������� 141 142 v4l2_device_disconnect(struct v4l2_device *v4l2_dev); 143 144���������������*���*������������������������������������������ v4l2_device_unregister() 145������������������������������������������������������������������������ v4l2_device_disconnect()��� 146 147������������������������������������������������������������������������������������������������������ 148������������������������������������ivtvfb ��������������������� ivtv ��������������������������� 149������ alsa ��������������������������� 150 151��������������������������������������������������������� 152 153static int callback(struct device *dev, void *p) 154{ 155 struct v4l2_device *v4l2_dev = dev_get_drvdata(dev); 156 157 /* ��������������������������������������� */ 158 if (v4l2_dev == NULL) 159 return 0; 160 ... 161 return 0; 162} 163 164int iterate(void *p) 165{ 166 struct device_driver *drv; 167 int err; 168 169 /* ���PCI ���������������ivtv��������� 170 pci_bus_type������������. ������USB������������usb_bus_type��� */ 171 drv = driver_find("ivtv", &pci_bus_type); 172 /* ���������������ivtv������������ */ 173 err = driver_for_each_device(drv, NULL, p, callback); 174 put_driver(drv); 175 return err; 176} 177 178������������������������������������������������������������������������������������������������������ 179������������������������������ 180 181��������������������� 182 183static atomic_t drv_instance = ATOMIC_INIT(0); 184 185static int drv_probe(struct pci_dev *pdev, const struct pci_device_id *pci_id) 186{ 187 ... 188 state->instance = atomic_inc_return(&drv_instance) - 1; 189} 190 191��������������������������������������������������������������������������� v4l2_device ��������� 192������������������������ v4l2_device ��������������������������������� video_register_device 193������������������������������������������������������������������������������������������������ 194v4l2_device ���release() ��������������������������������������������������������������������� 195 196������������������������������������������ ALSA������������������������������������������������ 197��������������� 198 199void v4l2_device_get(struct v4l2_device *v4l2_dev); 200 201���: 202 203int v4l2_device_put(struct v4l2_device *v4l2_dev); 204 205������������������������������ 1 ������������������ disconnect() ��������������� USB ������������ 206������ v4l2_device_put��������� remove() ��������������������� PCI ������������������ 207������������������������������ 0 ��� 208 209v4l2_subdev��������� 210------------------ 211 212��������������������������������������������������������������������������������������������������� 213������������������������������������������������������������������������������������������������������ 214 215��������������� I2C ������������������������������������������������������������������������������ 216���������������v4l2_subdev ������������v4l2-subdev.h��������������� 217 218��������������������������������������� v4l2_subdev ��������������������������������������� 219������������������������������������������������������������������������������������������������������ 220������������������������������������������������������������������������i2c_client������������ 221������������������������������������������ v4l2_set_subdevdata() ��������������������� 222��������������� v4l2_subdev ������������������(dev_priv)��������������������� v4l2_subdev 223������������������������������������������������������������ 224 225��������������������������������������������� v4l2_subdev ��������������������������������� 226i2c_client ������������i2c_set_clientdata() ��������������������������� v4l2_subdev 227��������������������������������������������������������������������� 228 229������������������������������������������������������������������������������������������������������ 230������������������������ v4l2_subdev ������������������������������������(host_priv)��� 231������������ v4l2_get_subdev_hostdata() ��� v4l2_set_subdev_hostdata() 232��������� 233 234��������������������������������������������������������������������������������� v4l2_subdev 235������������������������ i2c ��������������������������������� i2c_get_clientdata()��� 236������������������������������������������������������ I2C ��������������������������������������� 237������������������������������������ 238 239������ v4l2_subdev ������������������������������������������������������������������������ 240������������������NULL��������������������������������������������������������������������������� 241��������������������������������������������������������������������������������������������������� 242������������������������������������������������������������������������������������������������ 243 244������������������������������������������������������������������������������������������������������ 245������������������������������������������������������������������������������������NULL��� 246 247������������������������������ 248 249struct v4l2_subdev_core_ops { 250 int (*log_status)(struct v4l2_subdev *sd); 251 int (*init)(struct v4l2_subdev *sd, u32 val); 252 ... 253}; 254 255struct v4l2_subdev_tuner_ops { 256 ... 257}; 258 259struct v4l2_subdev_audio_ops { 260 ... 261}; 262 263struct v4l2_subdev_video_ops { 264 ... 265}; 266 267struct v4l2_subdev_pad_ops { 268 ... 269}; 270 271struct v4l2_subdev_ops { 272 const struct v4l2_subdev_core_ops *core; 273 const struct v4l2_subdev_tuner_ops *tuner; 274 const struct v4l2_subdev_audio_ops *audio; 275 const struct v4l2_subdev_video_ops *video; 276 const struct v4l2_subdev_pad_ops *video; 277}; 278 279������ core������������������������������������������������������������������������������������ 280������������������������������������������������������������������������������ 281 282������������������������������������������������������������������������������������������������ 283��������������������� 284 285��������������������������������������������� v4l2_subdev ������������ 286 287 v4l2_subdev_init(sd, &ops); 288 289��������������������������������������������������� subdev->name������������������������ 290owner ��������������� i2c ��������������������������������������������� 291 292��������������������������������������������� media_entity_init() ��������� v4l2_subdev 293��������������� media_entity ������������entity ��������� 294 295 struct media_pad *pads = &my_sd->pads; 296 int err; 297 298 err = media_entity_init(&sd->entity, npads, pads, 0); 299 300pads ������������������������������������������������ media_entity ��� type ��� 301name ������������������������revision ��������������������� 302 303���������������������������������������/������������ entity ���������������������������/��������� 304 305������������������������������������������������ media_entity ������������ 306 307 media_entity_cleanup(&sd->entity); 308 309������������������������������������������������������������������������������������ v4l2_subdev_pad_ops 310������ v4l2_subdev_video_ops ������������������������������ 311 312��������������������������������������������� link_validate ��������������������������������� 313��������������������������������������������������������������������� V4L2 ������������������������ 314��������������������������������������������������������������������������������������������� 315 316������ link_validate ������������������������������ v4l2_subdev_link_validate_default() 317������������������������������������������������������������������������������������������������������ 318������������������������������������������������������������������������������������������������������ 319������������������������ 320 321������������������������������������ v4l2_device ������ v4l2_subdev��� 322 323 int err = v4l2_device_register_subdev(v4l2_dev, sd); 324 325��������������������������������������������������������������������������������������������������������� 326subdev->dev ��������������� v4l2_device��� 327 328������ v4l2_device ������������ mdev ��������� NULL ������������������������������������ 329������������������������ 330 331��������������������������������������� 332 333 v4l2_device_unregister_subdev(sd); 334 335������������������������������������������ sd->dev == NULL��� 336 337������������������������������������������������������������������������ 338 339 err = sd->ops->core->g_std(sd, &norm); 340 341��������������������������������������������� 342 343 err = v4l2_subdev_call(sd, core, g_std, &norm); 344 345������������������ NULL ��������������������� subdev ��� NULL������������-ENODEV��������� 346subdev->core ��� subdev->core->g_std ��� NULL������������ -ENOIOCTLCMD��� 347��������������� subdev->ops->core->g_std ops ������������������������ 348 349������������������������������������������������������������������������������ 350 351 v4l2_device_call_all(v4l2_dev, 0, core, g_std, &norm); 352 353��������������������������������������������������������������������������������������������������� 354��������������������������������������������� 355 356 err = v4l2_device_call_until_err(v4l2_dev, 0, core, g_std, &norm); 357 358��� -ENOIOCTLCMD ��������������������������������������������������������������������� -ENOIOCTLCMD 359������������������������������������ 0��� 360 361������������������������������������������������ ID������������ 0��������������������������������� 362��������������������������� 0 ������������������������ ID ������������������������������������������ 363��������������������������������������������������� sd->grp_id ��������������������������������� 3640��������������������������������������������������������������������������������� 365 366��� ID ������������������������������������������������������������������������������������������ 367��������������������������������������������������������������������������������������������������� 368������������������������������������������������������������������������ ID ������������ AUDIO_CONTROLLER��� 369������������ v4l2_device_call_all() ������������������ ID ��������������������������� 370��������������������������������������������� 371 372��������������������������������� v4l2_device ������������������������������������ 373v4l2_subdev_notify(sd, notification, arg)��������������������������������� 374notify() ��������������������������������������� -ENODEV��������������� notify() ������ 375��������� 376 377������ v4l2_subdev ��������������������������������������������������������������������������� 378��������������������������������������� I2C ������������������������������������������������ GPIO 379������������������������������������������������������������������������������������������ v4l2 380������������������������������������ 381 382 383V4L2 ���������������������API 384-------------------- 385 386������������ v4l2_subdev_ops ��������������������� API���V4L2 ������������������������ 387������������������������������������������ 388 389��������� /dev ��������������� v4l-subdevX ��������������������������������������������������� 390������������������������������������������������������������������������ V4L2_SUBDEV_FL_HAS_DEVNODE 391��������� 392 393������������������������ v4l2_device ��������������������� v4l2_device_register_subdev_nodes() 394������������������������������������ V4L2_SUBDEV_FL_HAS_DEVNODE ������������������ 395������������������������������������������������������������������������ 396 397������������������������ V4L2 API ������������������ 398 399VIDIOC_QUERYCTRL 400VIDIOC_QUERYMENU 401VIDIOC_G_CTRL 402VIDIOC_S_CTRL 403VIDIOC_G_EXT_CTRLS 404VIDIOC_S_EXT_CTRLS 405VIDIOC_TRY_EXT_CTRLS 406 407 ������ ioctls ��������� V4L2 ��������������������������������������������������� 408 ��������������������������������������������������������������������������������������� 409 ��������������������������������� V4L2 ��������������������� 410 411VIDIOC_DQEVENT 412VIDIOC_SUBSCRIBE_EVENT 413VIDIOC_UNSUBSCRIBE_EVENT 414 415 ������ ioctls ��������� V4L2 ��������������������������������������������������� 416 ��������������������������������������������������������������������������������������� 417 ��������������������������������� V4L2 ��������������������� 418 419 ������������������������������������������������������������������������ v4l2_subdev::flags 420 ��������� V4L2_SUBDEV_USES_EVENTS ������ v4l2_subdev::nevents 421 ��������������������������������������������������������������� v4l2_subdev::devnode 422 ������������������������������������������ 423 424 ������������������������������poll() ������������������������������ 425 426������ ioctls 427 428 ������������������������������ ioctls ��������� core::ioctl ������������������ 429 ��������������������� 430 431 432I2C ��������������� 433------------- 434 435������������������������������������������������������������������������(v4l2-common.h)��������� 436������������������������������ 437 438������ v4l2_subdev ��������������������������� I2C ��������� v4l2_subdev ��������� 439������������������ I2C ��������������������������������������������������������������������������� 440������������������������������������������ v4l2_subdev ������������ 441 442������������������������������������������������chipname��������������������������� 443 444struct chipname_state { 445 struct v4l2_subdev sd; 446 ... /* ������������������*/ 447}; 448 449��������� v4l2_subdev ��������������������������� 450 451 v4l2_i2c_subdev_init(&state->sd, client, subdev_ops); 452 453��������������������� v4l2_subdev ������������������������������������ v4l2_subdev ��� 454i2c_client ������������������ 455 456��������������������������� v4l2_subdev ������������ chipname_state ��������������� 457��������������������������������� 458 459static inline struct chipname_state *to_state(struct v4l2_subdev *sd) 460{ 461 return container_of(sd, struct chipname_state, sd); 462} 463 464������������������������������ v4l2_subdev ��������������������� i2c_client ��������� 465��������� 466 467 struct i2c_client *client = v4l2_get_subdevdata(sd); 468 469��������������������������������� i2c_client ��������������������� v4l2_subdev ��������� 470��������� 471 472 struct v4l2_subdev *sd = i2c_get_clientdata(client); 473 474��� remove()������������������������������������������ v4l2_device_unregister_subdev(sd)��� 475��������������������������������������������������������������������������������������������������� 476������������ 477 478������������������������������������������������ i2c ���������������remove()������������ 479��������������������������� i2c ��������������������������������� v4l2_subdev ��������� 480������������������������������������������������������ remove()��������������������� 481v4l2_device_unregister_subdev(sd)��������������������������������������� 482 483 484������������������������������������������ 485 486struct v4l2_subdev *sd = v4l2_i2c_new_subdev(v4l2_dev, adapter, 487 "module_foo", "chipid", 0x36, NULL); 488 489��������������������������������������������������������������������������������� NULL������ 490��������������� i2c ���������������������������i2c_adapter������ ���������������chip/address��� 491������������������ i2c_new_device()��������������������������������� v4l2_device 492������������������������ 493 494������������������ v4l2_i2c_new_subdev()��������������������������������������������� 495I2C ������������������������������������������������������������������������������������ 0 ��� 496��������������������������������������������������������� i2c ��������������������������������� 497��������� 498 499������������������������������������ NULL��� 500 501������������������ v4l2_i2c_new_subdev()��� chipid ��������������������������� 502���������������������������������������������������saa7114���������saa7115������������������ 503i2c ���������������������chipid ������������������������������������������������������������ 504i2c ������������������������������������������������������������������������������������ i2c 505��������������� i2c_device_id ��������������������������������������������������� 506 507��������������������������� 508 509v4l2_i2c_new_subdev_cfg��������������������������� irq ��� platform_data 510������������������addr���������probed_addrs������������������ addr ��������������������� 511������������������������������ probed_addrs ������������������������������������ 512 513������������������������������������������0x10������ 514 515struct v4l2_subdev *sd = v4l2_i2c_new_subdev_cfg(v4l2_dev, adapter, 516 "module_foo", "chipid", 0, NULL, 0, I2C_ADDRS(0x10)); 517 518v4l2_i2c_new_subdev_board ������������ i2c_board_info ������������������ 519������ irq���platform_data ��� add r��������������� i2c ��������� 520 521��������������������� s_config ������������������������������������������������������������ irq ��� 522platform_data ��������������������������� v4l2_i2c_new_(probed_)subdev ������ 523������������������ s_config������������ irq ��� 0 ��� platform_data ��� NULL ������ 524 525video_device��������� 526----------------- 527 528��� /dev ������������������������������������ video_device ���������(v4l2-dev.h) 529������������������������������������������������������������������������������������������ 530 531��������������������������� 532 533 struct video_device *vdev = video_device_alloc(); 534 535 if (vdev == NULL) 536 return -ENOMEM; 537 538 vdev->release = video_device_release; 539 540������������������������������������������������������������������ release()��������� 541 542 struct video_device *vdev = &my_vdev->vdev; 543 544 vdev->release = my_vdev_release; 545 546release()������������������������������������������ video_device ������������������ 547������������ 548 549��������� video_device_release()������������������ kfree ������������������������ 550��������� 551 552��������������������������� 553 554- v4l2_dev: ��������� v4l2_device ������������ 555 556- name: ��������������������������������������� 557 558- fops: ������������������ v4l2_file_operations ������������ 559 560- ioctl_ops: ���������������v4l2_ioctl_ops ��������� ioctl ��������� 561 (������������������������������������������������������!)��������������������������� 562 v4l2_ioctl_ops ���������. 563 564- lock: ������������������������������������������������������������ NULL ��������� 565 ������������������������ struct mutex_lock ��������������������������������� 566 ��� unlocked_ioctl ��������������������������������������������������������������� 567 ��������������������������� 568 569- prio: ������������������������������������������ VIDIOC_G/S_PRIORITY��������� 570 ��������� NULL��������������� v4l2_device ������ v4l2_prio_state ������������ 571 ������������������������������������������������������������������������������������������ 572 ��������� v4l2_prio_state ������������ 573 574- parent: ������������ NULL ������������������������������������ v4l2_device ��� 575 ������������������������������������������������������������ PCI ������������������������ 576 v4l2_device ������������������������ 577 578 cx88 ��������������������������������� v4l2_device ��������������������������������� 579 ������ PCI ������(cx8800)��������� MPEG PCI ������(cx8802)��������������� 580 v4l2_device ������������������ PCI ��������������������������������������������������� 581 video_device ������������������������������������ PCI ������������ 582 583��������������� v4l2_ioctl_ops��������������� v4l2_file_operations ������������ 584������ .unlocked_ioctl ������ video_ioctl2��� 585 586������������ .ioctl��������������������������������������� 587 588������������������������������������������ v4l2_ioctl_ops ������������������������������������ 589������������ video_device_register ������������������������������������������ ioctls��� 590 591void v4l2_disable_ioctl(struct video_device *vdev, unsigned int cmd); 592 593������������������������������������������������������������������������������������������������������ 594��������� v4l2_ioctl_ops ������������������������������������������ 595 596v4l2_file_operations ������������ file_operations ��������������������������� 597������������������ inode ������������������������������������������ 598 599��������������������������������������������������������� media_entity_init() ��������� 600��������� video_device ��������������� media_entity���entity ������������������ 601 602 struct media_pad *pad = &my_vdev->pad; 603 int err; 604 605 err = media_entity_init(&vdev->entity, 1, pad, 0); 606 607pads ������������������������������������������������������ media_entity ��� type ��� 608name ������ 609 610���������������������������������������/������������ entity ���������������������������/��������� 611 612v4l2_file_operations ������ 613-------------------------- 614 615������������ video_device ������������������������������ mutex_lock ������������������ 616��������������������������������������������������������������������������������������������������� 617������ unlocked_ioctl������������������ ioctls ��������������������������������������� 618 619 void v4l2_disable_ioctl_locking(struct video_device *vdev, unsigned int cmd); 620 621������: v4l2_disable_ioctl_locking(vdev, VIDIOC_DQBUF); 622 623������������������ video_device ������������������������ 624 625��������������� USB ������������������������������������������������������������������������������ 626��������������������������������� ioctls ��������������� 627 628��������������������������������������������������� mutex_lock ��� NULL������������������������ 629������������ 630 631������������������������������������������������������������������������������������������������������ 632������������������ USB ��������������������������������������������������������������������������� 633������������������������������������������������������������������������������������������ 634 635��������������������������������� ioctl ��������������������������������������������������������� 636������ videobuf������������������������������������ videobuf ��������������������������� 637videobuf ������������������������������������������������������������������������������������������ 638������������������������������������������������������������������������������������������������������ 639������������������������������������������������������ 640 641��������� videobuf2 ��������������������������� wait_prepare ��� wait_finish ������ 642������������������������/��������������������������������������� video_device ������������������ 643������������������ wait_prepare ��� wait_finish ���������������������������������/��������� 644 645������������������������������������������ v4l2_device_disconnect ��������������� 646 647video_device������ 648--------------- 649 650������������������������������������������������������������������������������ 651 652 err = video_register_device(vdev, VFL_TYPE_GRABBER, -1); 653 if (err) { 654 video_device_release(vdev); /* or kfree(my_vdev); */ 655 return err; 656 } 657 658������ v4l2_device ������������ mdev ��������� NULL ��������������������������������� 659������������������������ 660 661������������������������������������type��������������������������������� 662 663VFL_TYPE_GRABBER: ������������������/��������������� videoX 664VFL_TYPE_VBI: ��������������������������� vbiX (���������������������������������������) 665VFL_TYPE_RADIO: ������������������������ radioX 666 667���������������������������������������������������������������������������(������ videoX ������ X)��� 668���������������������-1������ v4l2 ��������������������������������������������������������������� 669������������������������������������������������������������������������������������������������������ 670������������������������������������������������������������������������������ video_register_device 671������������������������������������������������������������������������������������������������������ 672��������������������������������������������������������������������� 673 674������������������������������������������������������������������������������������������������������ 675������������������������������������������������������������������������������ 0 ��������������� 676��������������� 16 ������������������������������������������������������������������������������������ 677��� v4l2 ��������������������������������������������������������������������������������������� 678������������������������������������������������������������ 679 680��������������������������������������������������������������������������������������������� 681video_register_device_no_warn() ������������������������������������ 682 683������������������������������������������������������������������ /sys/class/video4linux 684��������������������������������������������������������� video0 ������������������������name������ 685���index���������������name������������������ video_device ������������������name��������� 686 687���index��������������������������������������������������������� video_register_device()��� 688������������������ 1 ������������������������������������������������ 0 ��������� 689 690������������������ udev ���������������������������������������������������������������������mpegX��� 691������ MPEG ������������������������������ 692 693������������������������������������������������������ 694 695- vfl_type: ��������� video_register_device ������������������ 696- minor: ��������������������������� 697- num: ������������������ (������ videoX ������ X)��� 698- index: ������������������ 699 700������������������������������������ video_device_release() ��������������������� 701video_device ������������������ video_device ������������������������������������������ 702������������������������vdev->release() ��������������������������������������������� 703��������������������������������������������������� 704 705 706video_device ������ 707---------------- 708 709���������������������������������������������������������������USB������������������������������ 710��������� 711 712 video_unregister_device(vdev); 713 714������������������ sysfs ������������������������������ udev ��������� /dev ��������������� 715 716video_unregister_device() ������������������������������������������������������������ 717USB ��������������������������������������������������������������������������������������������� 718������������������������������������������������������������������ release ��������������������������� 719 720������������������������������������������������������ vdev->release() ��������������������� 721������������������������������������������ 722 723������������������������������������������������������������������������������������ 724 725 media_entity_cleanup(&vdev->entity); 726 727������������ release ������������������ 728 729 730video_device ������������ 731--------------------- 732 733������������������������������������ 734 735- file/video_device ������������ 736 737��������������������������� video_device ������������������/��������������������������� 738 739void *video_get_drvdata(struct video_device *vdev); 740void video_set_drvdata(struct video_device *vdev, void *data); 741 742������������������ video_register_device() ��������� video_set_drvdata() 743��������������� 744 745������������������ 746 747struct video_device *video_devdata(struct file *file); 748 749������ file ������������������������ video_device ��������� 750 751video_drvdata ��������������������� video_get_drvdata ��� video_devdata 752������������ 753 754void *video_drvdata(struct file *file); 755 756������������������������������ video_device ������������������ v4l2_device ��������� 757��������� 758 759struct v4l2_device *v4l2_dev = vdev->v4l2_dev; 760 761- ��������������� 762 763video_device ��������������������������������������������������������������� 764 765const char *video_device_node_name(struct video_device *vdev); 766 767������������������������������������������ udev������������������������������������������������ 768������������������������ video_device::num ��� video_device::minor ������ 769 770 771������������������������ 772--------------- 773 774v4l2 ������ API ������������������������������������������������(���������videobuf���)��� 775������������������������������������������������������ read()���mmap() ��� overlay()��� 776������������������������������������������������������/������ DMA(videobuf-dma-sg)��� 777������ DMA(videobuf-dma-contig)������������������ USB ������������ vmalloc 778���������������(videobuf-vmalloc)��� 779 780��������� Documentation/video4linux/videobuf������������������������ videobuf 781��������������������� 782 783v4l2_fh ��������� 784------------- 785 786v4l2_fh ��������������������������������� V4L2 ��������������������������������������������������� 787������ video_device ������������������ 788������������ v4l2_fh ������������������������������������������������������VIDIOC_G/S_PRIORITY������ 789 790v4l2_fh ������������������ V4l2 ������������������������������������������ 791video_device->flags ������ V4L2_FL_USES_V4L2_FH ��������������������������� 792v4l2_fh ������������ file->private_data ������������������������������ v4l2_fh_init() 793��������������� 794 795v4l2_fh ������������������������������������������������������������������������������������ 796��������������������� file->private_data ������������ 797 798���������������������v4l2_fh ��������������������������������������������������������������������� 799��������� open() ��������� v4l2_fh_init+v4l2_fh_add��������� release() ��� 800������ v4l2_fh_del+v4l2_fh_exit��� 801 802������������������������ container_of ��������������������������������������������������������� 803 804struct my_fh { 805 int blah; 806 struct v4l2_fh fh; 807}; 808 809... 810 811int my_open(struct file *file) 812{ 813 struct my_fh *my_fh; 814 struct video_device *vfd; 815 int ret; 816 817 ... 818 819 my_fh = kzalloc(sizeof(*my_fh), GFP_KERNEL); 820 821 ... 822 823 v4l2_fh_init(&my_fh->fh, vfd); 824 825 ... 826 827 file->private_data = &my_fh->fh; 828 v4l2_fh_add(&my_fh->fh); 829 return 0; 830} 831 832int my_release(struct file *file) 833{ 834 struct v4l2_fh *fh = file->private_data; 835 struct my_fh *my_fh = container_of(fh, struct my_fh, fh); 836 837 ... 838 v4l2_fh_del(&my_fh->fh); 839 v4l2_fh_exit(&my_fh->fh); 840 kfree(my_fh); 841 return 0; 842} 843 844��������� v4l2_fh ������������������������ 845 846void v4l2_fh_init(struct v4l2_fh *fh, struct video_device *vdev) 847 848 ���������������������������*������*������������ v4l2_file_operations->open() 849 ������������������ 850 851void v4l2_fh_add(struct v4l2_fh *fh) 852 853 ������������ v4l2_fh ��� video_device ��������������������������������������� 854 ��������������������������������� 855 856void v4l2_fh_del(struct v4l2_fh *fh) 857 858 ��� video_device() ��������������������������������������������������������������� 859 ��������������� 860 861void v4l2_fh_exit(struct v4l2_fh *fh) 862 863 ��������������������������������� v4l2_fh ��������������������������������� 864 865 866������ v4l2_fh ������������������������������������������������������������������������ 867 868int v4l2_fh_open(struct file *filp) 869 870 ������������ v4l2_fh ��������������������������������������������� file ������������������ 871 video_device ��������������� 872 873int v4l2_fh_release(struct file *filp) 874 875 ��� file ������������������ video_device ������������������ v4l2_fh ��������� 876 v4l2_fh ������������������ 877 878������������������������������ v4l2_file_operation ��� open() ��� release() 879������������ 880 881 882������������������������������������������������������������������������������������������������ 883��������������������������������������������������� v4l2_fh ������������������������������ 884������������������������������������ 885 886int v4l2_fh_is_singular(struct v4l2_fh *fh) 887 888 ��������������������������������������������������������������� 1 ��������������� 0 ��� 889 890int v4l2_fh_is_singular_file(struct file *filp) 891 892 ������������������������ filp->private_data ������ v4l2_fh_is_singular��� 893 894 895V4L2 ������������ 896----------- 897 898V4L2 ��������������������������������������������������������������������������������������������� 899v4l2_fh ������������ V4L2 ��������������� 900 901 902��������������������������������� ID ������������ID ������������ V4L2 ��������������� 903������������ ID������������������������ ID ��� 0��� 904 905��������������������������������������������������������� kevent ������������������������ 906���������������������ID��������������������������� kevent ������������������������������ 907������������������������������������������������������������������������������������������ 908 909��������������������������������������������������� kevent ������������������������������ 910������������������������������������������ 911 912���������v4l2_subscribed_event ��������������������������������������� merge() ��� 913replace() ������������������������������������������������������������������������������������ 914replace() ��������������������������������������������������������������������������������� 915��������������������������������������������������������������������������������������������������� 916kevent ���������������������������������merge() ��������������������������������������������� 917��������������������������������������������������������������������������������������� kevent 918��������������������������������� 919 920��������������������������������������������������������������������������������� 921 922 923������ replace/merge ��������������������������������� v4l2-event.c ������������ 924��������������� ctrls_replace() ��� ctrls_merge() ��������� 925 926��������������������������������������������������������������������������������������������������� 927 928������������������ 929 930void v4l2_event_queue(struct video_device *vdev, const struct v4l2_event *ev) 931 932 ������������������������������������������������������������ type ��� data ������ 933 ������������ V4L2 ��������� 934 935int v4l2_event_subscribe(struct v4l2_fh *fh, 936 struct v4l2_event_subscription *sub, unsigned elems, 937 const struct v4l2_subscribed_event_ops *ops) 938 939 video_device->ioctl_ops->vidioc_subscribe_event ��������������������� 940 ������������ id ������������������������ v4l2_event_subscribe() ��������������������� 941 942 elems ������������������������������������������ 0���V4L2 ������������������������������������ 943 ������������������ 944 945 ops ������������������������������������������ 946 * add: ������������������������������������������������������������������������������ 947 ������������������������ 948 * del: ������������������������������������������ 949 * replace: ��������������������������������������������� 950 * merge: ��������������������������������������������������� 951 ��������������������������������������������������������������������� ops ������ NULL��� 952 953int v4l2_event_unsubscribe(struct v4l2_fh *fh, 954 struct v4l2_event_subscription *sub) 955 956 v4l2_ioctl_ops ��������������� vidioc_unsubscribe_event ��������������� 957 ������������������������������ v4l2_event_unsubscribe() ��������������������������� 958 959 ��������� V4L2_EVENT_ALL ������������������������������������������������������������ 960 ������������������������������ 961 962int v4l2_event_pending(struct v4l2_fh *fh) 963 964 ������������������������������������������������������poll������������ 965 966������������ poll ������������������������������������������������ 967v4l2_fh->wait (wait_queue_head_t ������)������������������ poll_wait()��� 968 969��������������������������������������������������������������������������������������������������� 970������������������������������������������������������������������������������������������������ 971V4L2_EVENT_PRIVATE_START + n * 1000 ��������� n ������������������������������ 972��������������������������������������������������������������������������������������������������� 973������������������class base + 1������ 974 975V4L2 ������������������������������������ OMAP3 ISP ��������� 976(drivers/media/video/omap3isp)������������ 977