[media] v4l: Rename vb2_queue.timestamp_type as timestamp_flags

tjh.dev / kernel

fork atom

Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git

kernel os linux

fork atom

[media] v4l: Rename vb2_queue.timestamp_type as timestamp_flags

The timestamp_type field used to contain only the timestamp type. Soon it
will be used for timestamp source flags as well. Rename the field
accordingly.

[m.chehab@samsung.com: do the change also to drivers/staging/media and at s2255]
Signed-off-by: Sakari Ailus <sakari.ailus@iki.fi>
Acked-by: Hans Verkuil <hans.verkuil@cisco.com>
Signed-off-by: Mauro Carvalho Chehab <m.chehab@samsung.com>

authored by

Sakari Ailus and committed by

Mauro Carvalho Chehab 12 years ago ade48681 939f1377

+53 -53

39 changed files

expand all collapse all

drivers

media

parport

bw-qcam.c

platform

blackfin

bfin_capture.c

coda.c

davinci

vpbe_display.c

vpif_capture.c

vpif_display.c

exynos-gsc

gsc-m2m.c

exynos4-is

fimc-capture.c

fimc-lite.c

fimc-m2m.c

m2m-deinterlace.c

mem2mem_testdev.c

mx2_emmaprp.c

s3c-camif

camif-capture.c

s5p-g2d

g2d.c

s5p-jpeg

jpeg-core.c

s5p-mfc

s5p_mfc.c

soc_camera

atmel-isi.c

mx2_camera.c

mx3_camera.c

rcar_vin.c

sh_mobile_ceu_camera.c

ti-vpe

vpe.c

vivi.c

vsp1

vsp1_video.c

usb

em28xx

em28xx-video.c

pwc

pwc-if.c

s2255

s2255drv.c

stk1160

stk1160-v4l.c

usbtv

usbtv-video.c

uvc

uvc_queue.c

v4l2-core

videobuf2-core.c

staging

media

dt3155v4l

dt3155v4l.c

go7007

go7007-v4l2.c

msi3101

sdr-msi3101.c

omap4iss

iss_video.c

solo6x10

solo6x10-v4l2-enc.c

solo6x10-v4l2.c

include

media

videobuf2-core.h

+1 -1

drivers/media/parport/bw-qcam.c

reviewed

··· 965 965 q->drv_priv = qcam; 966 966 q->ops = &qcam_video_qops; 967 967 q->mem_ops = &vb2_vmalloc_memops; 968 968 - q->timestamp_type = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC; 968 968 + q->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC; 969 969 err = vb2_queue_init(q); 970 970 if (err < 0) { 971 971 v4l2_err(v4l2_dev, "couldn't init vb2_queue for %s.\n", port->name);

+1 -1

drivers/media/platform/blackfin/bfin_capture.c

reviewed

··· 997 997 q->buf_struct_size = sizeof(struct bcap_buffer); 998 998 q->ops = &bcap_video_qops; 999 999 q->mem_ops = &vb2_dma_contig_memops; 1000 1000 - q->timestamp_type = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC; 1000 1000 + q->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC; 1001 1001 1002 1002 ret = vb2_queue_init(q); 1003 1003 if (ret)

+2 -2

drivers/media/platform/coda.c

reviewed

··· 2428 2428 src_vq->buf_struct_size = sizeof(struct v4l2_m2m_buffer); 2429 2429 src_vq->ops = &coda_qops; 2430 2430 src_vq->mem_ops = &vb2_dma_contig_memops; 2431 2431 - src_vq->timestamp_type = V4L2_BUF_FLAG_TIMESTAMP_COPY; 2431 2431 + src_vq->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_COPY; 2432 2432 2433 2433 ret = vb2_queue_init(src_vq); 2434 2434 if (ret) ··· 2440 2440 dst_vq->buf_struct_size = sizeof(struct v4l2_m2m_buffer); 2441 2441 dst_vq->ops = &coda_qops; 2442 2442 dst_vq->mem_ops = &vb2_dma_contig_memops; 2443 2443 - dst_vq->timestamp_type = V4L2_BUF_FLAG_TIMESTAMP_COPY; 2443 2443 + dst_vq->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_COPY; 2444 2444 2445 2445 return vb2_queue_init(dst_vq); 2446 2446 }

+1 -1

drivers/media/platform/davinci/vpbe_display.c

reviewed

··· 1415 1415 q->ops = &video_qops; 1416 1416 q->mem_ops = &vb2_dma_contig_memops; 1417 1417 q->buf_struct_size = sizeof(struct vpbe_disp_buffer); 1418 1418 - q->timestamp_type = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC; 1418 1418 + q->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC; 1419 1419 1420 1420 ret = vb2_queue_init(q); 1421 1421 if (ret) {

+1 -1

drivers/media/platform/davinci/vpif_capture.c

reviewed

··· 1023 1023 q->ops = &video_qops; 1024 1024 q->mem_ops = &vb2_dma_contig_memops; 1025 1025 q->buf_struct_size = sizeof(struct vpif_cap_buffer); 1026 1026 - q->timestamp_type = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC; 1026 1026 + q->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC; 1027 1027 1028 1028 ret = vb2_queue_init(q); 1029 1029 if (ret) {

+1 -1

drivers/media/platform/davinci/vpif_display.c

reviewed

··· 983 983 q->ops = &video_qops; 984 984 q->mem_ops = &vb2_dma_contig_memops; 985 985 q->buf_struct_size = sizeof(struct vpif_disp_buffer); 986 986 - q->timestamp_type = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC; 986 986 + q->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC; 987 987 988 988 ret = vb2_queue_init(q); 989 989 if (ret) {

+2 -2

drivers/media/platform/exynos-gsc/gsc-m2m.c

reviewed

··· 590 590 src_vq->ops = &gsc_m2m_qops; 591 591 src_vq->mem_ops = &vb2_dma_contig_memops; 592 592 src_vq->buf_struct_size = sizeof(struct v4l2_m2m_buffer); 593 593 - src_vq->timestamp_type = V4L2_BUF_FLAG_TIMESTAMP_COPY; 593 593 + src_vq->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_COPY; 594 594 595 595 ret = vb2_queue_init(src_vq); 596 596 if (ret) ··· 603 603 dst_vq->ops = &gsc_m2m_qops; 604 604 dst_vq->mem_ops = &vb2_dma_contig_memops; 605 605 dst_vq->buf_struct_size = sizeof(struct v4l2_m2m_buffer); 606 606 - dst_vq->timestamp_type = V4L2_BUF_FLAG_TIMESTAMP_COPY; 606 606 + dst_vq->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_COPY; 607 607 608 608 return vb2_queue_init(dst_vq); 609 609 }

+1 -1

drivers/media/platform/exynos4-is/fimc-capture.c

reviewed

··· 1782 1782 q->ops = &fimc_capture_qops; 1783 1783 q->mem_ops = &vb2_dma_contig_memops; 1784 1784 q->buf_struct_size = sizeof(struct fimc_vid_buffer); 1785 1785 - q->timestamp_type = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC; 1785 1785 + q->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC; 1786 1786 q->lock = &fimc->lock; 1787 1787 1788 1788 ret = vb2_queue_init(q);

+1 -1

drivers/media/platform/exynos4-is/fimc-lite.c

reviewed

··· 1313 1313 q->mem_ops = &vb2_dma_contig_memops; 1314 1314 q->buf_struct_size = sizeof(struct flite_buffer); 1315 1315 q->drv_priv = fimc; 1316 1316 - q->timestamp_type = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC; 1316 1316 + q->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC; 1317 1317 q->lock = &fimc->lock; 1318 1318 1319 1319 ret = vb2_queue_init(q);

+2 -2

drivers/media/platform/exynos4-is/fimc-m2m.c

reviewed

··· 557 557 src_vq->ops = &fimc_qops; 558 558 src_vq->mem_ops = &vb2_dma_contig_memops; 559 559 src_vq->buf_struct_size = sizeof(struct v4l2_m2m_buffer); 560 560 - src_vq->timestamp_type = V4L2_BUF_FLAG_TIMESTAMP_COPY; 560 560 + src_vq->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_COPY; 561 561 src_vq->lock = &ctx->fimc_dev->lock; 562 562 563 563 ret = vb2_queue_init(src_vq); ··· 570 570 dst_vq->ops = &fimc_qops; 571 571 dst_vq->mem_ops = &vb2_dma_contig_memops; 572 572 dst_vq->buf_struct_size = sizeof(struct v4l2_m2m_buffer); 573 573 - dst_vq->timestamp_type = V4L2_BUF_FLAG_TIMESTAMP_COPY; 573 573 + dst_vq->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_COPY; 574 574 dst_vq->lock = &ctx->fimc_dev->lock; 575 575 576 576 return vb2_queue_init(dst_vq);

+2 -2

drivers/media/platform/m2m-deinterlace.c

reviewed

··· 868 868 src_vq->buf_struct_size = sizeof(struct v4l2_m2m_buffer); 869 869 src_vq->ops = &deinterlace_qops; 870 870 src_vq->mem_ops = &vb2_dma_contig_memops; 871 871 - src_vq->timestamp_type = V4L2_BUF_FLAG_TIMESTAMP_COPY; 871 871 + src_vq->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_COPY; 872 872 q_data[V4L2_M2M_SRC].fmt = &formats[0]; 873 873 q_data[V4L2_M2M_SRC].width = 640; 874 874 q_data[V4L2_M2M_SRC].height = 480; ··· 885 885 dst_vq->buf_struct_size = sizeof(struct v4l2_m2m_buffer); 886 886 dst_vq->ops = &deinterlace_qops; 887 887 dst_vq->mem_ops = &vb2_dma_contig_memops; 888 888 - dst_vq->timestamp_type = V4L2_BUF_FLAG_TIMESTAMP_COPY; 888 888 + dst_vq->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_COPY; 889 889 q_data[V4L2_M2M_DST].fmt = &formats[0]; 890 890 q_data[V4L2_M2M_DST].width = 640; 891 891 q_data[V4L2_M2M_DST].height = 480;

+2 -2

drivers/media/platform/mem2mem_testdev.c

reviewed

··· 777 777 src_vq->buf_struct_size = sizeof(struct v4l2_m2m_buffer); 778 778 src_vq->ops = &m2mtest_qops; 779 779 src_vq->mem_ops = &vb2_vmalloc_memops; 780 780 - src_vq->timestamp_type = V4L2_BUF_FLAG_TIMESTAMP_COPY; 780 780 + src_vq->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_COPY; 781 781 src_vq->lock = &ctx->dev->dev_mutex; 782 782 783 783 ret = vb2_queue_init(src_vq); ··· 790 790 dst_vq->buf_struct_size = sizeof(struct v4l2_m2m_buffer); 791 791 dst_vq->ops = &m2mtest_qops; 792 792 dst_vq->mem_ops = &vb2_vmalloc_memops; 793 793 - dst_vq->timestamp_type = V4L2_BUF_FLAG_TIMESTAMP_COPY; 793 793 + dst_vq->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_COPY; 794 794 dst_vq->lock = &ctx->dev->dev_mutex; 795 795 796 796 return vb2_queue_init(dst_vq);

+2 -2

drivers/media/platform/mx2_emmaprp.c

reviewed

··· 766 766 src_vq->buf_struct_size = sizeof(struct v4l2_m2m_buffer); 767 767 src_vq->ops = &emmaprp_qops; 768 768 src_vq->mem_ops = &vb2_dma_contig_memops; 769 769 - src_vq->timestamp_type = V4L2_BUF_FLAG_TIMESTAMP_COPY; 769 769 + src_vq->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_COPY; 770 770 771 771 ret = vb2_queue_init(src_vq); 772 772 if (ret) ··· 778 778 dst_vq->buf_struct_size = sizeof(struct v4l2_m2m_buffer); 779 779 dst_vq->ops = &emmaprp_qops; 780 780 dst_vq->mem_ops = &vb2_dma_contig_memops; 781 781 - dst_vq->timestamp_type = V4L2_BUF_FLAG_TIMESTAMP_COPY; 781 781 + dst_vq->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_COPY; 782 782 783 783 return vb2_queue_init(dst_vq); 784 784 }

+1 -1

drivers/media/platform/s3c-camif/camif-capture.c

reviewed

··· 1160 1160 q->mem_ops = &vb2_dma_contig_memops; 1161 1161 q->buf_struct_size = sizeof(struct camif_buffer); 1162 1162 q->drv_priv = vp; 1163 1163 - q->timestamp_type = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC; 1163 1163 + q->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC; 1164 1164 1165 1165 ret = vb2_queue_init(q); 1166 1166 if (ret)

+2 -2

drivers/media/platform/s5p-g2d/g2d.c

reviewed

··· 157 157 src_vq->ops = &g2d_qops; 158 158 src_vq->mem_ops = &vb2_dma_contig_memops; 159 159 src_vq->buf_struct_size = sizeof(struct v4l2_m2m_buffer); 160 160 - src_vq->timestamp_type = V4L2_BUF_FLAG_TIMESTAMP_COPY; 160 160 + src_vq->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_COPY; 161 161 src_vq->lock = &ctx->dev->mutex; 162 162 163 163 ret = vb2_queue_init(src_vq); ··· 170 170 dst_vq->ops = &g2d_qops; 171 171 dst_vq->mem_ops = &vb2_dma_contig_memops; 172 172 dst_vq->buf_struct_size = sizeof(struct v4l2_m2m_buffer); 173 173 - dst_vq->timestamp_type = V4L2_BUF_FLAG_TIMESTAMP_COPY; 173 173 + dst_vq->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_COPY; 174 174 dst_vq->lock = &ctx->dev->mutex; 175 175 176 176 return vb2_queue_init(dst_vq);

+2 -2

drivers/media/platform/s5p-jpeg/jpeg-core.c

reviewed

··· 1701 1701 src_vq->buf_struct_size = sizeof(struct v4l2_m2m_buffer); 1702 1702 src_vq->ops = &s5p_jpeg_qops; 1703 1703 src_vq->mem_ops = &vb2_dma_contig_memops; 1704 1704 - src_vq->timestamp_type = V4L2_BUF_FLAG_TIMESTAMP_COPY; 1704 1704 + src_vq->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_COPY; 1705 1705 src_vq->lock = &ctx->jpeg->lock; 1706 1706 1707 1707 ret = vb2_queue_init(src_vq); ··· 1714 1714 dst_vq->buf_struct_size = sizeof(struct v4l2_m2m_buffer); 1715 1715 dst_vq->ops = &s5p_jpeg_qops; 1716 1716 dst_vq->mem_ops = &vb2_dma_contig_memops; 1717 1717 - dst_vq->timestamp_type = V4L2_BUF_FLAG_TIMESTAMP_COPY; 1717 1717 + dst_vq->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_COPY; 1718 1718 dst_vq->lock = &ctx->jpeg->lock; 1719 1719 1720 1720 return vb2_queue_init(dst_vq);

+2 -2

drivers/media/platform/s5p-mfc/s5p_mfc.c

reviewed

··· 794 794 goto err_queue_init; 795 795 } 796 796 q->mem_ops = (struct vb2_mem_ops *)&vb2_dma_contig_memops; 797 797 - q->timestamp_type = V4L2_BUF_FLAG_TIMESTAMP_COPY; 797 797 + q->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_COPY; 798 798 ret = vb2_queue_init(q); 799 799 if (ret) { 800 800 mfc_err("Failed to initialize videobuf2 queue(capture)\n"); ··· 816 816 goto err_queue_init; 817 817 } 818 818 q->mem_ops = (struct vb2_mem_ops *)&vb2_dma_contig_memops; 819 819 - q->timestamp_type = V4L2_BUF_FLAG_TIMESTAMP_COPY; 819 819 + q->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_COPY; 820 820 ret = vb2_queue_init(q); 821 821 if (ret) { 822 822 mfc_err("Failed to initialize videobuf2 queue(output)\n");

+1 -1

drivers/media/platform/soc_camera/atmel-isi.c

reviewed

··· 472 472 q->buf_struct_size = sizeof(struct frame_buffer); 473 473 q->ops = &isi_video_qops; 474 474 q->mem_ops = &vb2_dma_contig_memops; 475 475 - q->timestamp_type = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC; 475 475 + q->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC; 476 476 477 477 return vb2_queue_init(q); 478 478 }

+1 -1

drivers/media/platform/soc_camera/mx2_camera.c

reviewed

··· 794 794 q->ops = &mx2_videobuf_ops; 795 795 q->mem_ops = &vb2_dma_contig_memops; 796 796 q->buf_struct_size = sizeof(struct mx2_buffer); 797 797 - q->timestamp_type = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC; 797 797 + q->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC; 798 798 799 799 return vb2_queue_init(q); 800 800 }

+1 -1

drivers/media/platform/soc_camera/mx3_camera.c

reviewed

··· 453 453 q->ops = &mx3_videobuf_ops; 454 454 q->mem_ops = &vb2_dma_contig_memops; 455 455 q->buf_struct_size = sizeof(struct mx3_camera_buffer); 456 456 - q->timestamp_type = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC; 456 456 + q->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC; 457 457 458 458 return vb2_queue_init(q); 459 459 }

+1 -1

drivers/media/platform/soc_camera/rcar_vin.c

reviewed

··· 1360 1360 vq->ops = &rcar_vin_vb2_ops; 1361 1361 vq->mem_ops = &vb2_dma_contig_memops; 1362 1362 vq->buf_struct_size = sizeof(struct rcar_vin_buffer); 1363 1363 - vq->timestamp_type = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC; 1363 1363 + vq->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC; 1364 1364 1365 1365 return vb2_queue_init(vq); 1366 1366 }

+1 -1

drivers/media/platform/soc_camera/sh_mobile_ceu_camera.c

reviewed

··· 1665 1665 q->ops = &sh_mobile_ceu_videobuf_ops; 1666 1666 q->mem_ops = &vb2_dma_contig_memops; 1667 1667 q->buf_struct_size = sizeof(struct sh_mobile_ceu_buffer); 1668 1668 - q->timestamp_type = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC; 1668 1668 + q->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC; 1669 1669 1670 1670 return vb2_queue_init(q); 1671 1671 }

+2 -2

drivers/media/platform/ti-vpe/vpe.c

reviewed

··· 1770 1770 src_vq->buf_struct_size = sizeof(struct v4l2_m2m_buffer); 1771 1771 src_vq->ops = &vpe_qops; 1772 1772 src_vq->mem_ops = &vb2_dma_contig_memops; 1773 1773 - src_vq->timestamp_type = V4L2_BUF_FLAG_TIMESTAMP_COPY; 1773 1773 + src_vq->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_COPY; 1774 1774 1775 1775 ret = vb2_queue_init(src_vq); 1776 1776 if (ret) ··· 1783 1783 dst_vq->buf_struct_size = sizeof(struct v4l2_m2m_buffer); 1784 1784 dst_vq->ops = &vpe_qops; 1785 1785 dst_vq->mem_ops = &vb2_dma_contig_memops; 1786 1786 - dst_vq->timestamp_type = V4L2_BUF_FLAG_TIMESTAMP_COPY; 1786 1786 + dst_vq->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_COPY; 1787 1787 1788 1788 return vb2_queue_init(dst_vq); 1789 1789 }

+1 -1

drivers/media/platform/vivi.c

reviewed

··· 1429 1429 q->buf_struct_size = sizeof(struct vivi_buffer); 1430 1430 q->ops = &vivi_video_qops; 1431 1431 q->mem_ops = &vb2_vmalloc_memops; 1432 1432 - q->timestamp_type = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC; 1432 1432 + q->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC; 1433 1433 1434 1434 ret = vb2_queue_init(q); 1435 1435 if (ret)

+1 -1

drivers/media/platform/vsp1/vsp1_video.c

reviewed

··· 1051 1051 video->queue.buf_struct_size = sizeof(struct vsp1_video_buffer); 1052 1052 video->queue.ops = &vsp1_video_queue_qops; 1053 1053 video->queue.mem_ops = &vb2_dma_contig_memops; 1054 1054 - video->queue.timestamp_type = V4L2_BUF_FLAG_TIMESTAMP_COPY; 1054 1054 + video->queue.timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_COPY; 1055 1055 ret = vb2_queue_init(&video->queue); 1056 1056 if (ret < 0) { 1057 1057 dev_err(video->vsp1->dev, "failed to initialize vb2 queue\n");

+2 -2

drivers/media/usb/em28xx/em28xx-video.c

reviewed

··· 1029 1029 q = &dev->vb_vidq; 1030 1030 q->type = V4L2_BUF_TYPE_VIDEO_CAPTURE; 1031 1031 q->io_modes = VB2_READ | VB2_MMAP | VB2_USERPTR | VB2_DMABUF; 1032 1032 - q->timestamp_type = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC; 1032 1032 + q->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC; 1033 1033 q->drv_priv = dev; 1034 1034 q->buf_struct_size = sizeof(struct em28xx_buffer); 1035 1035 q->ops = &em28xx_video_qops; ··· 1043 1043 q = &dev->vb_vbiq; 1044 1044 q->type = V4L2_BUF_TYPE_VBI_CAPTURE; 1045 1045 q->io_modes = VB2_READ | VB2_MMAP | VB2_USERPTR; 1046 1046 - q->timestamp_type = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC; 1046 1046 + q->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC; 1047 1047 q->drv_priv = dev; 1048 1048 q->buf_struct_size = sizeof(struct em28xx_buffer); 1049 1049 q->ops = &em28xx_vbi_qops;

+1 -1

drivers/media/usb/pwc/pwc-if.c

reviewed

··· 1001 1001 pdev->vb_queue.buf_struct_size = sizeof(struct pwc_frame_buf); 1002 1002 pdev->vb_queue.ops = &pwc_vb_queue_ops; 1003 1003 pdev->vb_queue.mem_ops = &vb2_vmalloc_memops; 1004 1004 - pdev->vb_queue.timestamp_type = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC; 1004 1004 + pdev->vb_queue.timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC; 1005 1005 rc = vb2_queue_init(&pdev->vb_queue); 1006 1006 if (rc < 0) { 1007 1007 PWC_ERROR("Oops, could not initialize vb2 queue.\n");

+1 -1

drivers/media/usb/s2255/s2255drv.c

reviewed

··· 1664 1664 q->buf_struct_size = sizeof(struct s2255_buffer); 1665 1665 q->mem_ops = &vb2_vmalloc_memops; 1666 1666 q->ops = &s2255_video_qops; 1667 1667 - q->timestamp_type = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC; 1667 1667 + q->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC; 1668 1668 ret = vb2_queue_init(q); 1669 1669 if (ret != 0) { 1670 1670 dev_err(&dev->udev->dev,

+1 -1

drivers/media/usb/stk1160/stk1160-v4l.c

reviewed

··· 641 641 q->buf_struct_size = sizeof(struct stk1160_buffer); 642 642 q->ops = &stk1160_video_qops; 643 643 q->mem_ops = &vb2_vmalloc_memops; 644 644 - q->timestamp_type = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC; 644 644 + q->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC; 645 645 646 646 rc = vb2_queue_init(q); 647 647 if (rc < 0)

+1 -1

drivers/media/usb/usbtv/usbtv-video.c

reviewed

··· 679 679 usbtv->vb2q.buf_struct_size = sizeof(struct usbtv_buf); 680 680 usbtv->vb2q.ops = &usbtv_vb2_ops; 681 681 usbtv->vb2q.mem_ops = &vb2_vmalloc_memops; 682 682 - usbtv->vb2q.timestamp_type = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC; 682 682 + usbtv->vb2q.timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC; 683 683 usbtv->vb2q.lock = &usbtv->vb2q_lock; 684 684 ret = vb2_queue_init(&usbtv->vb2q); 685 685 if (ret < 0) {

+1 -1

drivers/media/usb/uvc/uvc_queue.c

reviewed

··· 151 151 queue->queue.buf_struct_size = sizeof(struct uvc_buffer); 152 152 queue->queue.ops = &uvc_queue_qops; 153 153 queue->queue.mem_ops = &vb2_vmalloc_memops; 154 154 - queue->queue.timestamp_type = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC; 154 154 + queue->queue.timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC; 155 155 ret = vb2_queue_init(&queue->queue); 156 156 if (ret) 157 157 return ret;

+4 -4

drivers/media/v4l2-core/videobuf2-core.c

reviewed

··· 488 488 * Clear any buffer state related flags. 489 489 */ 490 490 b->flags &= ~V4L2_BUFFER_MASK_FLAGS; 491 491 - b->flags |= q->timestamp_type; 491 491 + b->flags |= q->timestamp_flags; 492 492 493 493 switch (vb->state) { 494 494 case VB2_BUF_STATE_QUEUED: ··· 1473 1473 * For output buffers copy the timestamp if needed, 1474 1474 * and the timecode field and flag if needed. 1475 1475 */ 1476 1476 - if (q->timestamp_type == V4L2_BUF_FLAG_TIMESTAMP_COPY) 1476 1476 + if (q->timestamp_flags == V4L2_BUF_FLAG_TIMESTAMP_COPY) 1477 1477 vb->v4l2_buf.timestamp = b->timestamp; 1478 1478 vb->v4l2_buf.flags |= b->flags & V4L2_BUF_FLAG_TIMECODE; 1479 1479 if (b->flags & V4L2_BUF_FLAG_TIMECODE) ··· 2226 2226 WARN_ON(!q->io_modes) || 2227 2227 WARN_ON(!q->ops->queue_setup) || 2228 2228 WARN_ON(!q->ops->buf_queue) || 2229 2229 - WARN_ON(q->timestamp_type & ~V4L2_BUF_FLAG_TIMESTAMP_MASK)) 2229 2229 + WARN_ON(q->timestamp_flags & ~V4L2_BUF_FLAG_TIMESTAMP_MASK)) 2230 2230 return -EINVAL; 2231 2231 2232 2232 /* Warn that the driver should choose an appropriate timestamp type */ 2233 2233 - WARN_ON(q->timestamp_type == V4L2_BUF_FLAG_TIMESTAMP_UNKNOWN); 2233 2233 + WARN_ON(q->timestamp_flags == V4L2_BUF_FLAG_TIMESTAMP_UNKNOWN); 2234 2234 2235 2235 INIT_LIST_HEAD(&q->queued_list); 2236 2236 INIT_LIST_HEAD(&q->done_list);

+1 -1

drivers/staging/media/dt3155v4l/dt3155v4l.c

reviewed

··· 391 391 goto err_alloc_queue; 392 392 } 393 393 pd->q->type = V4L2_BUF_TYPE_VIDEO_CAPTURE; 394 394 - pd->q->timestamp_type = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC; 394 394 + pd->q->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC; 395 395 pd->q->io_modes = VB2_READ | VB2_MMAP; 396 396 pd->q->ops = &q_ops; 397 397 pd->q->mem_ops = &vb2_dma_contig_memops;

+1 -1

drivers/staging/media/go7007/go7007-v4l2.c

reviewed

··· 989 989 go->vidq.mem_ops = &vb2_vmalloc_memops; 990 990 go->vidq.drv_priv = go; 991 991 go->vidq.buf_struct_size = sizeof(struct go7007_buffer); 992 992 - go->vidq.timestamp_type = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC; 992 992 + go->vidq.timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC; 993 993 go->vidq.lock = &go->queue_lock; 994 994 rv = vb2_queue_init(&go->vidq); 995 995 if (rv)

+1 -1

drivers/staging/media/msi3101/sdr-msi3101.c

reviewed

··· 1851 1851 s->vb_queue.buf_struct_size = sizeof(struct msi3101_frame_buf); 1852 1852 s->vb_queue.ops = &msi3101_vb2_ops; 1853 1853 s->vb_queue.mem_ops = &vb2_vmalloc_memops; 1854 1854 - s->vb_queue.timestamp_type = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC; 1854 1854 + s->vb_queue.timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC; 1855 1855 ret = vb2_queue_init(&s->vb_queue); 1856 1856 if (ret < 0) { 1857 1857 dev_err(&s->udev->dev, "Could not initialize vb2 queue\n");

+1 -1

drivers/staging/media/omap4iss/iss_video.c

reviewed

··· 1074 1074 q->ops = &iss_video_vb2ops; 1075 1075 q->mem_ops = &vb2_dma_contig_memops; 1076 1076 q->buf_struct_size = sizeof(struct iss_buffer); 1077 1077 - q->timestamp_type = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC; 1077 1077 + q->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC; 1078 1078 1079 1079 ret = vb2_queue_init(q); 1080 1080 if (ret) {

+1 -1

drivers/staging/media/solo6x10/solo6x10-v4l2-enc.c

reviewed

··· 1290 1290 solo_enc->vidq.mem_ops = &vb2_dma_sg_memops; 1291 1291 solo_enc->vidq.drv_priv = solo_enc; 1292 1292 solo_enc->vidq.gfp_flags = __GFP_DMA32; 1293 1293 - solo_enc->vidq.timestamp_type = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC; 1293 1293 + solo_enc->vidq.timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC; 1294 1294 solo_enc->vidq.buf_struct_size = sizeof(struct solo_vb2_buf); 1295 1295 solo_enc->vidq.lock = &solo_enc->lock; 1296 1296 ret = vb2_queue_init(&solo_enc->vidq);

+1 -1

drivers/staging/media/solo6x10/solo6x10-v4l2.c

reviewed

··· 676 676 solo_dev->vidq.ops = &solo_video_qops; 677 677 solo_dev->vidq.mem_ops = &vb2_dma_contig_memops; 678 678 solo_dev->vidq.drv_priv = solo_dev; 679 679 - solo_dev->vidq.timestamp_type = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC; 679 679 + solo_dev->vidq.timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC; 680 680 solo_dev->vidq.gfp_flags = __GFP_DMA32; 681 681 solo_dev->vidq.buf_struct_size = sizeof(struct solo_vb2_buf); 682 682 solo_dev->vidq.lock = &solo_dev->lock;

+1 -1

include/media/videobuf2-core.h

reviewed

··· 342 342 const struct vb2_mem_ops *mem_ops; 343 343 void *drv_priv; 344 344 unsigned int buf_struct_size; 345 345 - u32 timestamp_type; 345 345 + u32 timestamp_flags; 346 346 gfp_t gfp_flags; 347 347 348 348 /* private: internal use only */