From 775ae0473ba4869419fcd7cb7977566c69067e9c Mon Sep 17 00:00:00 2001 From: Julian Seward Date: Thu, 4 Sep 2014 11:08:45 +0000 Subject: [PATCH] Patch adding support for V4L2/media ioctls. Patch from Hans Verkuil (hverkuil@xs4all.nl). Fixes #338023. git-svn-id: svn://svn.valgrind.org/valgrind/trunk@14455 --- coregrind/m_syswrap/syswrap-linux.c | 1445 +++++++++++++++++++++++++++ include/vki/vki-linux.h | 930 +++++++++++++++++ 2 files changed, 2375 insertions(+) diff --git a/coregrind/m_syswrap/syswrap-linux.c b/coregrind/m_syswrap/syswrap-linux.c index 1fafd559ec..fd5bf0c9ac 100644 --- a/coregrind/m_syswrap/syswrap-linux.c +++ b/coregrind/m_syswrap/syswrap-linux.c @@ -5424,6 +5424,9 @@ PRE(sys_ioctl) /* InfiniBand */ case VKI_IB_USER_MAD_ENABLE_PKEY: + + /* V4L2 */ + case VKI_V4L2_LOG_STATUS: PRINT("sys_ioctl ( %ld, 0x%lx )",ARG1,ARG2); PRE_REG_READ2(long, "ioctl", unsigned int, fd, unsigned int, request); @@ -7150,6 +7153,956 @@ PRE(sys_ioctl) sizeof(struct vki_getinfo_fid2path)); break; + /* V4L2 */ + case VKI_V4L2_QUERYCAP: { + struct vki_v4l2_capability *data = (struct vki_v4l2_capability *)ARG3; + PRE_MEM_WRITE("ioctl(VKI_V4L2_QUERYCAP)", (Addr)data, sizeof(*data)); + break; + } + case VKI_V4L2_ENUM_FMT: { + struct vki_v4l2_fmtdesc *data = (struct vki_v4l2_fmtdesc *)ARG3; + PRE_FIELD_READ("ioctl(VKI_V4L2_ENUM_FMT).index", data->index); + PRE_FIELD_READ("ioctl(VKI_V4L2_ENUM_FMT).type", data->type); + PRE_FIELD_WRITE("ioctl(VKI_V4L2_ENUM_FMT).flags", data->flags); + PRE_FIELD_WRITE("ioctl(VKI_V4L2_ENUM_FMT).description", data->description); + PRE_FIELD_WRITE("ioctl(VKI_V4L2_ENUM_FMT).pixelformat", data->pixelformat); + PRE_FIELD_WRITE("ioctl(VKI_V4L2_ENUM_FMT).reserved", data->reserved); + break; + } + case VKI_V4L2_G_FMT: { + struct vki_v4l2_format *data = (struct vki_v4l2_format *)ARG3; + PRE_FIELD_READ("ioctl(VKI_V4L2_G_FMT).type", data->type); + switch (data->type) { + case VKI_V4L2_BUF_TYPE_VIDEO_CAPTURE: + case VKI_V4L2_BUF_TYPE_VIDEO_OUTPUT: + PRE_FIELD_READ("ioctl(VKI_V4L2_G_FMT).fmt.pix.priv", data->fmt.pix.priv); + PRE_FIELD_WRITE("ioctl(VKI_V4L2_G_FMT).fmt.pix", data->fmt.pix); + PRE_MEM_READ("ioctl(VKI_V4L2_G_FMT)", + (Addr)&data->type + sizeof(data->type) + sizeof(data->fmt.pix), + sizeof(*data) - sizeof(data->type) - sizeof(data->fmt.pix)); + break; + case VKI_V4L2_BUF_TYPE_VBI_CAPTURE: + case VKI_V4L2_BUF_TYPE_VBI_OUTPUT: + PRE_FIELD_WRITE("ioctl(VKI_V4L2_G_FMT).fmt.vbi", data->fmt.vbi); + break; + case VKI_V4L2_BUF_TYPE_SLICED_VBI_CAPTURE: + case VKI_V4L2_BUF_TYPE_SLICED_VBI_OUTPUT: + PRE_FIELD_WRITE("ioctl(VKI_V4L2_G_FMT).fmt.sliced", data->fmt.sliced); + break; + case VKI_V4L2_BUF_TYPE_VIDEO_OVERLAY: + case VKI_V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY: + PRE_FIELD_READ("ioctl(VKI_V4L2_G_FMT).fmt.win.clips", data->fmt.win.clips); + PRE_FIELD_READ("ioctl(VKI_V4L2_G_FMT).fmt.win.bitmap", data->fmt.win.bitmap); + PRE_FIELD_READ("ioctl(VKI_V4L2_G_FMT).fmt.win.clipcount", data->fmt.win.clipcount); + if (data->fmt.win.clipcount && data->fmt.win.clips) + PRE_MEM_WRITE("ioctl(VKI_V4L2_G_FMT).fmt.win.clips[]", + (Addr)data->fmt.win.clips, + data->fmt.win.clipcount * sizeof(data->fmt.win.clips[0])); + PRE_FIELD_WRITE("ioctl(VKI_V4L2_G_FMT).fmt.win.clipcount", data->fmt.win.clipcount); + PRE_FIELD_WRITE("ioctl(VKI_V4L2_G_FMT).fmt.win.w", data->fmt.win.w); + PRE_FIELD_WRITE("ioctl(VKI_V4L2_G_FMT).fmt.win.field", data->fmt.win.field); + PRE_FIELD_WRITE("ioctl(VKI_V4L2_G_FMT).fmt.win.chromakey", data->fmt.win.chromakey); + PRE_FIELD_WRITE("ioctl(VKI_V4L2_G_FMT).fmt.win.global_alpha", data->fmt.win.global_alpha); + break; + case VKI_V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE: + case VKI_V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE: + PRE_FIELD_WRITE("ioctl(VKI_V4L2_G_FMT).fmt.pix_mp", data->fmt.pix_mp); + break; + case VKI_V4L2_BUF_TYPE_SDR_CAPTURE: + PRE_FIELD_WRITE("ioctl(VKI_V4L2_G_FMT).fmt.sdr", data->fmt.sdr); + break; + } + break; + } + case VKI_V4L2_S_FMT: { + struct vki_v4l2_format *data = (struct vki_v4l2_format *)ARG3; + PRE_FIELD_READ("ioctl(VKI_V4L2_S_FMT).type", data->type); + switch (data->type) { + case VKI_V4L2_BUF_TYPE_VIDEO_CAPTURE: + case VKI_V4L2_BUF_TYPE_VIDEO_OUTPUT: + PRE_MEM_READ("ioctl(VKI_V4L2_S_FMT)", + (Addr)&data->type + sizeof(data->type), + sizeof(*data) - sizeof(data->type)); + break; + case VKI_V4L2_BUF_TYPE_VBI_CAPTURE: + case VKI_V4L2_BUF_TYPE_VBI_OUTPUT: + PRE_FIELD_READ("ioctl(VKI_V4L2_S_FMT).fmt.vbi", data->fmt.vbi); + break; + case VKI_V4L2_BUF_TYPE_SLICED_VBI_CAPTURE: + case VKI_V4L2_BUF_TYPE_SLICED_VBI_OUTPUT: + PRE_FIELD_READ("ioctl(VKI_V4L2_S_FMT).fmt.sliced", data->fmt.sliced); + break; + case VKI_V4L2_BUF_TYPE_VIDEO_OVERLAY: + case VKI_V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY: + PRE_FIELD_READ("ioctl(VKI_V4L2_S_FMT).fmt.win", data->fmt.win); + if (data->fmt.win.clipcount && data->fmt.win.clips) + PRE_MEM_READ("ioctl(VKI_V4L2_S_FMT).fmt.win.clips[]", + (Addr)data->fmt.win.clips, + data->fmt.win.clipcount * sizeof(data->fmt.win.clips[0])); + if (data->fmt.win.bitmap) + PRE_MEM_READ("ioctl(VKI_V4L2_S_FMT).fmt.win.bitmap[]", + (Addr)data->fmt.win.bitmap, + data->fmt.win.w.height * ((data->fmt.win.w.width + 7) / 8)); + break; + case VKI_V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE: + case VKI_V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE: + PRE_FIELD_READ("ioctl(VKI_V4L2_S_FMT).fmt.pix_mp", data->fmt.pix_mp); + break; + case VKI_V4L2_BUF_TYPE_SDR_CAPTURE: + PRE_FIELD_READ("ioctl(VKI_V4L2_S_FMT).fmt.sdr", data->fmt.sdr); + break; + } + break; + } + case VKI_V4L2_TRY_FMT: { + struct vki_v4l2_format *data = (struct vki_v4l2_format *)ARG3; + PRE_FIELD_READ("ioctl(VKI_V4L2_TRY_FMT).type", data->type); + switch (data->type) { + case VKI_V4L2_BUF_TYPE_VIDEO_CAPTURE: + case VKI_V4L2_BUF_TYPE_VIDEO_OUTPUT: + PRE_MEM_READ("ioctl(VKI_V4L2_TRY_FMT)", + (Addr)&data->type + sizeof(data->type), + sizeof(*data) - sizeof(data->type)); + break; + case VKI_V4L2_BUF_TYPE_VBI_CAPTURE: + case VKI_V4L2_BUF_TYPE_VBI_OUTPUT: + PRE_FIELD_READ("ioctl(VKI_V4L2_TRY_FMT).fmt.vbi", data->fmt.vbi); + break; + case VKI_V4L2_BUF_TYPE_SLICED_VBI_CAPTURE: + case VKI_V4L2_BUF_TYPE_SLICED_VBI_OUTPUT: + PRE_FIELD_READ("ioctl(VKI_V4L2_TRY_FMT).fmt.sliced", data->fmt.sliced); + break; + case VKI_V4L2_BUF_TYPE_VIDEO_OVERLAY: + case VKI_V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY: + PRE_FIELD_READ("ioctl(VKI_V4L2_TRY_FMT).fmt.win", data->fmt.win); + if (data->fmt.win.clipcount && data->fmt.win.clips) + PRE_MEM_READ("ioctl(VKI_V4L2_TRY_FMT).fmt.win.clips[]", + (Addr)data->fmt.win.clips, + data->fmt.win.clipcount * sizeof(data->fmt.win.clips[0])); + if (data->fmt.win.bitmap) + PRE_MEM_READ("ioctl(VKI_V4L2_TRY_FMT).fmt.win.bitmap[]", + (Addr)data->fmt.win.bitmap, + data->fmt.win.w.height * ((data->fmt.win.w.width + 7) / 8)); + break; + case VKI_V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE: + case VKI_V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE: + PRE_FIELD_READ("ioctl(VKI_V4L2_TRY_FMT).fmt.pix_mp", data->fmt.pix_mp); + break; + case VKI_V4L2_BUF_TYPE_SDR_CAPTURE: + PRE_FIELD_READ("ioctl(VKI_V4L2_TRY_FMT).fmt.sdr", data->fmt.sdr); + break; + } + break; + } + case VKI_V4L2_REQBUFS: { + struct vki_v4l2_requestbuffers *data = (struct vki_v4l2_requestbuffers *)ARG3; + PRE_MEM_READ("ioctl(VKI_V4L2_REQBUFS)", (Addr)data, sizeof(*data)); + break; + } + case VKI_V4L2_QUERYBUF: { + struct vki_v4l2_buffer *data = (struct vki_v4l2_buffer *)ARG3; + PRE_FIELD_READ("ioctl(VKI_V4L2_QUERYBUF).type", data->type); + PRE_FIELD_READ("ioctl(VKI_V4L2_QUERYBUF).index", data->index); + PRE_FIELD_READ("ioctl(VKI_V4L2_QUERYBUF).reserved", data->reserved); + PRE_FIELD_READ("ioctl(VKI_V4L2_QUERYBUF).reserved2", data->reserved2); + if (data->type == VKI_V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE || + data->type == VKI_V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE) { + unsigned i; + + PRE_FIELD_READ("ioctl(VKI_V4L2_QUERYBUF).length", data->length); + PRE_FIELD_READ("ioctl(VKI_V4L2_QUERYBUF).m.planes", data->m.planes); + for (i = 0; i < data->length; i++) { + PRE_FIELD_WRITE("ioctl(VKI_V4L2_QUERYBUF).m.planes[].bytesused", data->m.planes[i].bytesused); + PRE_FIELD_WRITE("ioctl(VKI_V4L2_QUERYBUF).m.planes[].length", data->m.planes[i].length); + PRE_FIELD_WRITE("ioctl(VKI_V4L2_QUERYBUF).m.planes[].m", data->m.planes[i].m); + PRE_FIELD_WRITE("ioctl(VKI_V4L2_QUERYBUF).m.planes[].data_offset", data->m.planes[i].data_offset); + PRE_FIELD_WRITE("ioctl(VKI_V4L2_QUERYBUF).m.planes[].reserved", data->m.planes[i].reserved); + } + } else { + PRE_FIELD_WRITE("ioctl(VKI_V4L2_QUERYBUF).m", data->m); + PRE_FIELD_WRITE("ioctl(VKI_V4L2_QUERYBUF).length", data->length); + } + PRE_FIELD_WRITE("ioctl(VKI_V4L2_QUERYBUF).bytesused", data->bytesused); + PRE_FIELD_WRITE("ioctl(VKI_V4L2_QUERYBUF).flags", data->flags); + PRE_FIELD_WRITE("ioctl(VKI_V4L2_QUERYBUF).field", data->field); + PRE_FIELD_WRITE("ioctl(VKI_V4L2_QUERYBUF).timestamp", data->timestamp); + PRE_FIELD_WRITE("ioctl(VKI_V4L2_QUERYBUF).timecode", data->timecode); + PRE_FIELD_WRITE("ioctl(VKI_V4L2_QUERYBUF).sequence", data->sequence); + PRE_FIELD_WRITE("ioctl(VKI_V4L2_QUERYBUF).memory", data->memory); + PRE_FIELD_WRITE("ioctl(VKI_V4L2_QUERYBUF).sequence", data->sequence); + break; + } + case VKI_V4L2_G_FBUF: { + struct vki_v4l2_framebuffer *data = (struct vki_v4l2_framebuffer *)ARG3; + PRE_MEM_WRITE("ioctl(VKI_V4L2_G_FBUF)", (Addr)data, sizeof(*data)); + break; + } + case VKI_V4L2_S_FBUF: { + struct vki_v4l2_framebuffer *data = (struct vki_v4l2_framebuffer *)ARG3; + PRE_FIELD_WRITE("ioctl(VKI_V4L2_S_FBUF).capability", data->capability); + PRE_FIELD_READ("ioctl(VKI_V4L2_S_FBUF).flags", data->flags); + PRE_FIELD_READ("ioctl(VKI_V4L2_S_FBUF).base", data->base); + PRE_FIELD_READ("ioctl(VKI_V4L2_S_FBUF).fmt", data->fmt); + break; + } + case VKI_V4L2_OVERLAY: { + int *data = (int *)ARG3; + PRE_MEM_READ("ioctl(VKI_V4L2_OVERLAY)", (Addr)data, sizeof(*data)); + break; + } + case VKI_V4L2_QBUF: { + struct vki_v4l2_buffer *data = (struct vki_v4l2_buffer *)ARG3; + int is_output = data->type == VKI_V4L2_BUF_TYPE_VIDEO_OUTPUT || + data->type == VKI_V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE || + data->type == VKI_V4L2_BUF_TYPE_VBI_OUTPUT || + data->type == VKI_V4L2_BUF_TYPE_SLICED_VBI_OUTPUT; + + PRE_FIELD_READ("ioctl(VKI_V4L2_QBUF).type", data->type); + PRE_FIELD_READ("ioctl(VKI_V4L2_QBUF).index", data->index); + PRE_FIELD_READ("ioctl(VKI_V4L2_QBUF).flags", data->flags); + PRE_FIELD_READ("ioctl(VKI_V4L2_QBUF).memory", data->memory); + PRE_FIELD_READ("ioctl(VKI_V4L2_QBUF).reserved", data->reserved); + PRE_FIELD_READ("ioctl(VKI_V4L2_QBUF).reserved2", data->reserved2); + if (is_output) { + PRE_FIELD_READ("ioctl(VKI_V4L2_QBUF).bytesused", data->bytesused); + PRE_FIELD_READ("ioctl(VKI_V4L2_QBUF).field", data->field); + } + if (data->type == VKI_V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE || + data->type == VKI_V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE) { + unsigned i; + + PRE_FIELD_READ("ioctl(VKI_V4L2_QBUF).length", data->length); + PRE_FIELD_READ("ioctl(VKI_V4L2_QBUF).m.planes", data->m.planes); + for (i = 0; i < data->length; i++) { + if (is_output) { + PRE_FIELD_READ("ioctl(VKI_V4L2_QBUF).m.planes[].bytesused", data->m.planes[i].bytesused); + PRE_FIELD_READ("ioctl(VKI_V4L2_QBUF).m.planes[].data_offset", data->m.planes[i].data_offset); + } + if (data->memory == VKI_V4L2_MEMORY_MMAP) + PRE_FIELD_WRITE("ioctl(VKI_V4L2_QBUF).m.planes[].m", data->m.planes[i].m); + else if (data->memory == VKI_V4L2_MEMORY_DMABUF) + PRE_FIELD_READ("ioctl(VKI_V4L2_QBUF).m.planes[].m.fd", data->m.planes[i].m.fd); + else + PRE_FIELD_READ("ioctl(VKI_V4L2_QBUF).m.planes[].m", data->m.planes[i].m); + PRE_FIELD_READ("ioctl(VKI_V4L2_QBUF).m.planes[].reserved", data->m.planes[i].reserved); + } + } else { + if (data->memory == VKI_V4L2_MEMORY_MMAP) + PRE_FIELD_WRITE("ioctl(VKI_V4L2_QBUF).m", data->m); + else if (data->memory == VKI_V4L2_MEMORY_DMABUF) + PRE_FIELD_READ("ioctl(VKI_V4L2_QBUF).m.fd", data->m.fd); + else + PRE_FIELD_READ("ioctl(VKI_V4L2_QBUF).m", data->m); + if (is_output) { + PRE_FIELD_READ("ioctl(VKI_V4L2_QBUF).bytesused", data->bytesused); + PRE_FIELD_READ("ioctl(VKI_V4L2_QBUF).field", data->field); + } + } + if (is_output && (data->flags & VKI_V4L2_BUF_FLAG_TIMESTAMP_MASK) == VKI_V4L2_BUF_FLAG_TIMESTAMP_COPY) { + PRE_FIELD_READ("ioctl(VKI_V4L2_QBUF).timestamp", data->timestamp); + PRE_FIELD_READ("ioctl(VKI_V4L2_QBUF).timecode", data->timecode); + } + break; + } + case VKI_V4L2_EXPBUF: { + struct vki_v4l2_exportbuffer *data = (struct vki_v4l2_exportbuffer *)ARG3; + PRE_FIELD_READ("ioctl(VKI_V4L2_EXPBUF).type", data->type); + PRE_FIELD_READ("ioctl(VKI_V4L2_EXPBUF).index", data->index); + PRE_FIELD_READ("ioctl(VKI_V4L2_EXPBUF).plane", data->plane); + PRE_FIELD_READ("ioctl(VKI_V4L2_EXPBUF).flags", data->flags); + PRE_FIELD_WRITE("ioctl(VKI_V4L2_EXPBUF).fd", data->fd); + PRE_FIELD_READ("ioctl(VKI_V4L2_EXPBUF).reserved", data->reserved); + break; + } + case VKI_V4L2_DQBUF: { + struct vki_v4l2_buffer *data = (struct vki_v4l2_buffer *)ARG3; + PRE_FIELD_READ("ioctl(VKI_V4L2_DQBUF).type", data->type); + PRE_FIELD_WRITE("ioctl(VKI_V4L2_DQBUF).index", data->index); + PRE_FIELD_READ("ioctl(VKI_V4L2_DQBUF).memory", data->memory); + PRE_FIELD_READ("ioctl(VKI_V4L2_DQBUF).reserved", data->reserved); + PRE_FIELD_READ("ioctl(VKI_V4L2_DQBUF).reserved2", data->reserved2); + PRE_FIELD_WRITE("ioctl(VKI_V4L2_DQBUF).bytesused", data->bytesused); + PRE_FIELD_WRITE("ioctl(VKI_V4L2_DQBUF).field", data->field); + if (data->type == VKI_V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE || + data->type == VKI_V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE) { + unsigned i; + + PRE_FIELD_READ("ioctl(VKI_V4L2_DQBUF).length", data->length); + PRE_FIELD_READ("ioctl(VKI_V4L2_DQBUF).m.planes", data->m.planes); + for (i = 0; i < data->length; i++) { + PRE_FIELD_WRITE("ioctl(VKI_V4L2_DQBUF).m.planes[].bytesused", data->m.planes[i].bytesused); + PRE_FIELD_WRITE("ioctl(VKI_V4L2_DQBUF).m.planes[].data_offset", data->m.planes[i].data_offset); + PRE_FIELD_WRITE("ioctl(VKI_V4L2_DQBUF).m.planes[].length", data->m.planes[i].length); + PRE_FIELD_WRITE("ioctl(VKI_V4L2_DQBUF).m.planes[].m", data->m.planes[i].m); + PRE_FIELD_READ("ioctl(VKI_V4L2_DQBUF).m.planes[].reserved", data->m.planes[i].reserved); + } + } else { + PRE_FIELD_WRITE("ioctl(VKI_V4L2_DQBUF).m", data->m); + PRE_FIELD_WRITE("ioctl(VKI_V4L2_DQBUF).length", data->length); + PRE_FIELD_WRITE("ioctl(VKI_V4L2_DQBUF).bytesused", data->bytesused); + PRE_FIELD_WRITE("ioctl(VKI_V4L2_DQBUF).field", data->field); + } + PRE_FIELD_WRITE("ioctl(VKI_V4L2_DQBUF).timestamp", data->timestamp); + PRE_FIELD_WRITE("ioctl(VKI_V4L2_DQBUF).timecode", data->timecode); + PRE_FIELD_WRITE("ioctl(VKI_V4L2_DQBUF).sequence", data->sequence); + break; + } + case VKI_V4L2_STREAMON: { + int *data = (int *)ARG3; + PRE_MEM_READ("ioctl(VKI_V4L2_STREAMON)", (Addr)data, sizeof(*data)); + break; + } + case VKI_V4L2_STREAMOFF: { + int *data = (int *)ARG3; + PRE_MEM_READ("ioctl(VKI_V4L2_STREAMOFF)", (Addr)data, sizeof(*data)); + break; + } + case VKI_V4L2_G_PARM: { + struct vki_v4l2_streamparm *data = (struct vki_v4l2_streamparm *)ARG3; + int is_output = data->type == VKI_V4L2_BUF_TYPE_VIDEO_OUTPUT || + data->type == VKI_V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE || + data->type == VKI_V4L2_BUF_TYPE_VBI_OUTPUT || + data->type == VKI_V4L2_BUF_TYPE_SLICED_VBI_OUTPUT; + + PRE_FIELD_READ("ioctl(VKI_V4L2_G_PARM).type", data->type); + if (is_output) { + PRE_MEM_WRITE("ioctl(VKI_V4L2_G_PARM)", (Addr)&data->parm.output, + sizeof(data->parm.output) - sizeof(data->parm.output.reserved)); + PRE_FIELD_READ("ioctl(VKI_V4L2_G_PARM).parm.output.reserved", data->parm.output.reserved); + } else { + PRE_MEM_WRITE("ioctl(VKI_V4L2_G_PARM)", (Addr)&data->parm.capture, + sizeof(data->parm.capture) - sizeof(data->parm.capture.reserved)); + PRE_FIELD_READ("ioctl(VKI_V4L2_G_PARM).parm.capture.reserved", data->parm.capture.reserved); + } + break; + } + case VKI_V4L2_S_PARM: { + struct vki_v4l2_streamparm *data = (struct vki_v4l2_streamparm *)ARG3; + int is_output = data->type == VKI_V4L2_BUF_TYPE_VIDEO_OUTPUT || + data->type == VKI_V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE || + data->type == VKI_V4L2_BUF_TYPE_VBI_OUTPUT || + data->type == VKI_V4L2_BUF_TYPE_SLICED_VBI_OUTPUT; + + PRE_FIELD_READ("ioctl(VKI_V4L2_S_PARM).type", data->type); + if (is_output) + PRE_FIELD_READ("ioctl(VKI_V4L2_S_PARM).parm.output", data->parm.output); + else + PRE_FIELD_READ("ioctl(VKI_V4L2_S_PARM).parm.capture", data->parm.capture); + break; + } + case VKI_V4L2_G_STD: { + vki_v4l2_std_id *data = (vki_v4l2_std_id *)ARG3; + PRE_MEM_WRITE("ioctl(VKI_V4L2_G_STD)", (Addr)data, sizeof(*data)); + break; + } + case VKI_V4L2_S_STD: { + vki_v4l2_std_id *data = (vki_v4l2_std_id *)ARG3; + PRE_MEM_READ("ioctl(VKI_V4L2_S_STD)", (Addr)data, sizeof(*data)); + break; + } + case VKI_V4L2_ENUMSTD: { + struct vki_v4l2_standard *data = (struct vki_v4l2_standard *)ARG3; + PRE_FIELD_READ("ioctl(VKI_V4L2_ENUMSTD).index", data->index); + PRE_MEM_WRITE("ioctl(VKI_V4L2_ENUMSTD)", (Addr)&data->id, sizeof(*data) - sizeof(data->index)); + break; + } + case VKI_V4L2_ENUMINPUT: { + struct vki_v4l2_input *data = (struct vki_v4l2_input *)ARG3; + PRE_FIELD_READ("ioctl(VKI_V4L2_ENUMINPUT).index", data->index); + PRE_MEM_WRITE("ioctl(VKI_V4L2_ENUMINPUT)", (Addr)data->name, sizeof(*data) - sizeof(data->index)); + break; + } + case VKI_V4L2_G_CTRL: { + struct vki_v4l2_control *data = (struct vki_v4l2_control *)ARG3; + PRE_FIELD_READ("ioctl(VKI_V4L2_G_CTRL).id", data->id); + PRE_FIELD_WRITE("ioctl(VKI_V4L2_G_CTRL).value", data->value); + break; + } + case VKI_V4L2_S_CTRL: { + struct vki_v4l2_control *data = (struct vki_v4l2_control *)ARG3; + PRE_MEM_READ("ioctl(VKI_V4L2_S_CTRL)", (Addr)data, sizeof(*data)); + break; + } + case VKI_V4L2_G_TUNER: { + struct vki_v4l2_tuner *data = (struct vki_v4l2_tuner *)ARG3; + PRE_FIELD_READ("ioctl(VKI_V4L2_G_TUNER).index", data->index); + PRE_FIELD_READ("ioctl(VKI_V4L2_G_TUNER).reserved", data->reserved); + PRE_MEM_WRITE("ioctl(VKI_V4L2_G_TUNER)", (Addr)data->name, + sizeof(*data) - sizeof(data->index) - sizeof(data->reserved)); + break; + } + case VKI_V4L2_S_TUNER: { + struct vki_v4l2_tuner *data = (struct vki_v4l2_tuner *)ARG3; + PRE_FIELD_READ("ioctl(VKI_V4L2_S_TUNER).index", data->index); + PRE_FIELD_READ("ioctl(VKI_V4L2_S_TUNER).audmode", data->audmode); + PRE_FIELD_READ("ioctl(VKI_V4L2_S_TUNER).reserved", data->reserved); + break; + } + case VKI_V4L2_G_AUDIO: { + struct vki_v4l2_audio *data = (struct vki_v4l2_audio *)ARG3; + PRE_FIELD_READ("ioctl(VKI_V4L2_G_AUDIO).index", data->index); + PRE_MEM_WRITE("ioctl(VKI_V4L2_G_AUDIO)", (Addr)data->name, + sizeof(*data) - sizeof(data->index) - sizeof(data->reserved)); + PRE_FIELD_READ("ioctl(VKI_V4L2_G_AUDIO).reserved", data->reserved); + break; + } + case VKI_V4L2_S_AUDIO: { + struct vki_v4l2_audio *data = (struct vki_v4l2_audio *)ARG3; + PRE_FIELD_READ("ioctl(VKI_V4L2_S_AUDIO).index", data->index); + PRE_FIELD_READ("ioctl(VKI_V4L2_S_AUDIO).mode", data->mode); + PRE_FIELD_READ("ioctl(VKI_V4L2_S_AUDIO).reserved", data->reserved); + break; + } + case VKI_V4L2_QUERYCTRL: { + struct vki_v4l2_queryctrl *data = (struct vki_v4l2_queryctrl *)ARG3; + PRE_FIELD_READ("ioctl(VKI_V4L2_QUERYCTRL).id", data->id); + PRE_MEM_WRITE("ioctl(VKI_V4L2_QUERYCTRL)", (Addr)&data->type, + sizeof(*data) - sizeof(data->id)); + break; + } + case VKI_V4L2_QUERYMENU: { + struct vki_v4l2_querymenu *data = (struct vki_v4l2_querymenu *)ARG3; + PRE_FIELD_READ("ioctl(VKI_V4L2_QUERYMENU).id", data->id); + PRE_FIELD_READ("ioctl(VKI_V4L2_QUERYMENU).index", data->index); + PRE_MEM_WRITE("ioctl(VKI_V4L2_QUERYMENU)", (Addr)data->name, + sizeof(*data) - sizeof(data->id) - sizeof(data->index)); + break; + } + case VKI_V4L2_G_INPUT: { + int *data = (int *)ARG3; + PRE_MEM_WRITE("ioctl(VKI_V4L2_G_INPUT)", (Addr)data, sizeof(*data)); + break; + } + case VKI_V4L2_S_INPUT: { + int *data = (int *)ARG3; + PRE_MEM_READ("ioctl(VKI_V4L2_S_INPUT)", (Addr)data, sizeof(*data)); + break; + } + case VKI_V4L2_G_EDID: { + struct vki_v4l2_edid *data = (struct vki_v4l2_edid *)ARG3; + PRE_MEM_READ("ioctl(VKI_V4L2_G_EDID)", (Addr)data, sizeof(*data)); + if (data->blocks && data->edid) + PRE_MEM_WRITE("ioctl(VKI_V4L2_G_EDID)", (Addr)data->edid, data->blocks * 128); + break; + } + case VKI_V4L2_S_EDID: { + struct vki_v4l2_edid *data = (struct vki_v4l2_edid *)ARG3; + PRE_MEM_READ("ioctl(VKI_V4L2_S_EDID)", (Addr)data, sizeof(*data)); + if (data->blocks && data->edid) + PRE_MEM_READ("ioctl(VKI_V4L2_S_EDID)", (Addr)data->edid, data->blocks * 128); + break; + } + case VKI_V4L2_G_OUTPUT: { + int *data = (int *)ARG3; + PRE_MEM_WRITE("ioctl(VKI_V4L2_G_OUTPUT)", (Addr)data, sizeof(*data)); + break; + } + case VKI_V4L2_S_OUTPUT: { + int *data = (int *)ARG3; + PRE_MEM_READ("ioctl(VKI_V4L2_S_OUTPUT)", (Addr)data, sizeof(*data)); + break; + } + case VKI_V4L2_ENUMOUTPUT: { + struct vki_v4l2_output *data = (struct vki_v4l2_output *)ARG3; + PRE_FIELD_READ("ioctl(VKI_V4L2_ENUMOUTPUT).index", data->index); + PRE_MEM_WRITE("ioctl(VKI_V4L2_ENUMOUTPUT)", (Addr)data->name, sizeof(*data) - sizeof(data->index)); + break; + } + case VKI_V4L2_G_AUDOUT: { + struct vki_v4l2_audioout *data = (struct vki_v4l2_audioout *)ARG3; + PRE_FIELD_READ("ioctl(VKI_V4L2_G_AUDOUT).index", data->index); + PRE_FIELD_READ("ioctl(VKI_V4L2_G_AUDOUT).reserved", data->reserved); + PRE_MEM_WRITE("ioctl(VKI_V4L2_G_AUDOUT)", (Addr)data->name, + sizeof(*data) - sizeof(data->index) - sizeof(data->reserved)); + break; + } + case VKI_V4L2_S_AUDOUT: { + struct vki_v4l2_audioout *data = (struct vki_v4l2_audioout *)ARG3; + PRE_FIELD_READ("ioctl(VKI_V4L2_S_AUDOUT).index", data->index); + PRE_FIELD_READ("ioctl(VKI_V4L2_S_AUDOUT).reserved", data->reserved); + PRE_FIELD_READ("ioctl(VKI_V4L2_S_AUDOUT).mode", data->mode); + break; + } + case VKI_V4L2_G_MODULATOR: { + struct vki_v4l2_modulator *data = (struct vki_v4l2_modulator *)ARG3; + PRE_FIELD_READ("ioctl(VKI_V4L2_G_MODULATOR).index", data->index); + PRE_FIELD_READ("ioctl(VKI_V4L2_G_MODULATOR).reserved", data->reserved); + PRE_MEM_WRITE("ioctl(VKI_V4L2_G_MODULATOR)", (Addr)data->name, + sizeof(*data) - sizeof(data->index) - sizeof(data->reserved)); + break; + } + case VKI_V4L2_S_MODULATOR: { + struct vki_v4l2_modulator *data = (struct vki_v4l2_modulator *)ARG3; + PRE_FIELD_READ("ioctl(VKI_V4L2_S_MODULATOR).index", data->index); + PRE_FIELD_READ("ioctl(VKI_V4L2_S_MODULATOR).txsubchans", data->txsubchans); + PRE_FIELD_READ("ioctl(VKI_V4L2_S_MODULATOR).reserved", data->reserved); + break; + } + case VKI_V4L2_G_FREQUENCY: { + struct vki_v4l2_frequency *data = (struct vki_v4l2_frequency *)ARG3; + PRE_FIELD_READ("ioctl(VKI_V4L2_G_FREQUENCY).tuner", data->tuner); + PRE_FIELD_READ("ioctl(VKI_V4L2_G_FREQUENCY).reserved", data->reserved); + PRE_FIELD_WRITE("ioctl(VKI_V4L2_G_FREQUENCY).type", data->type); + PRE_FIELD_WRITE("ioctl(VKI_V4L2_G_FREQUENCY).frequency", data->frequency); + break; + } + case VKI_V4L2_S_FREQUENCY: { + struct vki_v4l2_frequency *data = (struct vki_v4l2_frequency *)ARG3; + PRE_MEM_READ("ioctl(VKI_V4L2_S_FREQUENCY)", (Addr)data, sizeof(*data)); + break; + } + case VKI_V4L2_CROPCAP: { + struct vki_v4l2_cropcap *data = (struct vki_v4l2_cropcap *)ARG3; + PRE_FIELD_READ("ioctl(VKI_V4L2_CROPCAP)", data->type); + PRE_MEM_WRITE("ioctl(VKI_V4L2_CROPCAP)", (Addr)&data->bounds, sizeof(*data) - sizeof(data->type)); + break; + } + case VKI_V4L2_G_CROP: { + struct vki_v4l2_crop *data = (struct vki_v4l2_crop *)ARG3; + PRE_FIELD_READ("ioctl(VKI_V4L2_G_CROP).type", data->type); + PRE_FIELD_WRITE("ioctl(VKI_V4L2_G_CROP).c", data->c); + break; + } + case VKI_V4L2_S_CROP: { + struct vki_v4l2_crop *data = (struct vki_v4l2_crop *)ARG3; + PRE_MEM_READ("ioctl(VKI_V4L2_S_CROP)", (Addr)data, sizeof(*data)); + break; + } + case VKI_V4L2_G_JPEGCOMP: { + struct vki_v4l2_jpegcompression *data = (struct vki_v4l2_jpegcompression *)ARG3; + PRE_MEM_WRITE("ioctl(VKI_V4L2_G_JPEGCOMP)", (Addr)data, sizeof(*data)); + break; + } + case VKI_V4L2_S_JPEGCOMP: { + struct vki_v4l2_jpegcompression *data = (struct vki_v4l2_jpegcompression *)ARG3; + PRE_MEM_READ("ioctl(VKI_V4L2_S_JPEGCOMP)", (Addr)data, sizeof(*data)); + break; + } + case VKI_V4L2_QUERYSTD: { + vki_v4l2_std_id *data = (vki_v4l2_std_id *)ARG3; + PRE_MEM_WRITE("ioctl(VKI_V4L2_QUERYSTD)", (Addr)data, sizeof(*data)); + break; + } + case VKI_V4L2_ENUMAUDIO: { + struct vki_v4l2_audio *data = (struct vki_v4l2_audio *)ARG3; + PRE_FIELD_READ("ioctl(VKI_V4L2_ENUMAUDIO).index", data->index); + PRE_FIELD_READ("ioctl(VKI_V4L2_ENUMAUDIO).reserved", data->reserved); + PRE_MEM_WRITE("ioctl(VKI_V4L2_ENUMAUDIO)", (Addr)data->name, + sizeof(*data) - sizeof(data->index) - sizeof(data->reserved)); + break; + } + case VKI_V4L2_ENUMAUDOUT: { + struct vki_v4l2_audioout *data = (struct vki_v4l2_audioout *)ARG3; + PRE_FIELD_READ("ioctl(VKI_V4L2_ENUMAUDOUT).index", data->index); + PRE_FIELD_READ("ioctl(VKI_V4L2_ENUMAUDOUT).reserved", data->reserved); + PRE_MEM_WRITE("ioctl(VKI_V4L2_ENUMAUDOUT)", (Addr)data->name, + sizeof(*data) - sizeof(data->index) - sizeof(data->reserved)); + break; + } + case VKI_V4L2_G_PRIORITY: { + __vki_u32 *data = (__vki_u32 *)ARG3; + PRE_MEM_WRITE("ioctl(VKI_V4L2_G_PRIORITY)", (Addr)data, sizeof(*data)); + break; + } + case VKI_V4L2_S_PRIORITY: { + __vki_u32 *data = (__vki_u32 *)ARG3; + PRE_MEM_READ("ioctl(VKI_V4L2_S_PRIORITY)", (Addr)data, sizeof(*data)); + break; + } + case VKI_V4L2_G_SLICED_VBI_CAP: { + struct vki_v4l2_sliced_vbi_cap *data = (struct vki_v4l2_sliced_vbi_cap *)ARG3; + PRE_FIELD_READ("ioctl(VKI_V4L2_G_SLICED_VBI_CAP).type", data->type); + PRE_FIELD_READ("ioctl(VKI_V4L2_G_SLICED_VBI_CAP).reserved", data->reserved); + PRE_MEM_WRITE("ioctl(VKI_V4L2_G_SLICED_VBI_CAP)", (Addr)data, + sizeof(*data) - sizeof(data->type) - sizeof(data->reserved)); + break; + } + case VKI_V4L2_G_EXT_CTRLS: { + struct vki_v4l2_ext_controls *data = (struct vki_v4l2_ext_controls *)ARG3; + PRE_FIELD_READ("ioctl(VKI_V4L2_G_EXT_CTRLS).ctrl_class", data->ctrl_class); + PRE_FIELD_READ("ioctl(VKI_V4L2_G_EXT_CTRLS).count", data->count); + if (data->count) { + unsigned i; + + PRE_FIELD_READ("ioctl(VKI_V4L2_G_EXT_CTRLS).controls", data->controls); + for (i = 0; i < data->count; i++) { + PRE_FIELD_READ("ioctl(VKI_V4L2_G_EXT_CTRLS).controls[].id", data->controls[i].id); + PRE_FIELD_READ("ioctl(VKI_V4L2_G_EXT_CTRLS).controls[].size", data->controls[i].size); + PRE_FIELD_READ("ioctl(VKI_V4L2_G_EXT_CTRLS).controls[].reserved2", data->controls[i].reserved2); + if (data->controls[i].size) { + PRE_FIELD_READ("ioctl(VKI_V4L2_G_EXT_CTRLS).controls[].ptr", data->controls[i].ptr); + PRE_MEM_WRITE("ioctl(VKI_V4L2_G_EXT_CTRLS).controls[].ptr[]", + (Addr)data->controls[i].ptr, data->controls[i].size); + } else { + PRE_FIELD_WRITE("ioctl(VKI_V4L2_G_EXT_CTRLS).controls[].value64", + data->controls[i].value64); + } + } + } + PRE_FIELD_WRITE("ioctl(VKI_V4L2_G_EXT_CTRLS).error_idx", data->error_idx); + PRE_FIELD_READ("ioctl(VKI_V4L2_G_EXT_CTRLS).reserved", data->reserved); + break; + } + case VKI_V4L2_S_EXT_CTRLS: { + struct vki_v4l2_ext_controls *data = (struct vki_v4l2_ext_controls *)ARG3; + PRE_FIELD_READ("ioctl(VKI_V4L2_S_EXT_CTRLS).ctrl_class", data->ctrl_class); + PRE_FIELD_READ("ioctl(VKI_V4L2_S_EXT_CTRLS).count", data->count); + if (data->count) { + unsigned i; + + PRE_FIELD_READ("ioctl(VKI_V4L2_S_EXT_CTRLS).controls", data->controls); + PRE_MEM_READ("ioctl(VKI_V4L2_S_EXT_CTRLS)", (Addr)data->controls, + data->count * sizeof(data->controls[0])); + for (i = 0; i < data->count; i++) { + if (data->controls[i].size) { + PRE_MEM_READ("ioctl(VKI_V4L2_S_EXT_CTRLS).controls[].ptr[]", + (Addr)data->controls[i].ptr, data->controls[i].size); + } + } + } + PRE_FIELD_WRITE("ioctl(VKI_V4L2_S_EXT_CTRLS).error_idx", data->error_idx); + PRE_FIELD_READ("ioctl(VKI_V4L2_S_EXT_CTRLS).reserved", data->reserved); + break; + } + case VKI_V4L2_TRY_EXT_CTRLS: { + struct vki_v4l2_ext_controls *data = (struct vki_v4l2_ext_controls *)ARG3; + PRE_FIELD_READ("ioctl(VKI_V4L2_TRY_EXT_CTRLS).ctrl_class", data->ctrl_class); + PRE_FIELD_READ("ioctl(VKI_V4L2_TRY_EXT_CTRLS).count", data->count); + if (data->count) { + unsigned i; + + PRE_FIELD_READ("ioctl(VKI_V4L2_TRY_EXT_CTRLS).controls", data->controls); + PRE_MEM_READ("ioctl(VKI_V4L2_TRY_EXT_CTRLS)", (Addr)data->controls, + data->count * sizeof(data->controls[0])); + for (i = 0; i < data->count; i++) { + if (data->controls[i].size) { + PRE_MEM_READ("ioctl(VKI_V4L2_TRY_EXT_CTRLS).controls[].ptr[]", + (Addr)data->controls[i].ptr, data->controls[i].size); + } + } + } + PRE_FIELD_WRITE("ioctl(VKI_V4L2_TRY_EXT_CTRLS).error_idx", data->error_idx); + PRE_FIELD_READ("ioctl(VKI_V4L2_TRY_EXT_CTRLS).reserved", data->reserved); + break; + } + case VKI_V4L2_ENUM_FRAMESIZES: { + struct vki_v4l2_frmsizeenum *data = (struct vki_v4l2_frmsizeenum *)ARG3; + PRE_FIELD_READ("ioctl(VKI_V4L2_ENUM_FRAMESIZES).index", data->index); + PRE_FIELD_READ("ioctl(VKI_V4L2_ENUM_FRAMESIZES).pixel_format", data->pixel_format); + PRE_FIELD_READ("ioctl(VKI_V4L2_ENUM_FRAMESIZES).reserved", data->reserved); + PRE_FIELD_WRITE("ioctl(VKI_V4L2_ENUM_FRAMESIZES).type", data->type); + PRE_FIELD_WRITE("ioctl(VKI_V4L2_ENUM_FRAMESIZES).stepwise", data->stepwise); + break; + } + case VKI_V4L2_ENUM_FRAMEINTERVALS: { + struct vki_v4l2_frmivalenum *data = (struct vki_v4l2_frmivalenum *)ARG3; + PRE_FIELD_READ("ioctl(VKI_V4L2_ENUM_FRAMEINTERVALS).index", data->index); + PRE_FIELD_READ("ioctl(VKI_V4L2_ENUM_FRAMEINTERVALS).pixel_format", data->pixel_format); + PRE_FIELD_READ("ioctl(VKI_V4L2_ENUM_FRAMEINTERVALS).width", data->width); + PRE_FIELD_READ("ioctl(VKI_V4L2_ENUM_FRAMEINTERVALS).height", data->height); + PRE_FIELD_READ("ioctl(VKI_V4L2_ENUM_FRAMEINTERVALS).reserved", data->reserved); + PRE_FIELD_WRITE("ioctl(VKI_V4L2_ENUM_FRAMEINTERVALS).type", data->type); + PRE_FIELD_WRITE("ioctl(VKI_V4L2_ENUM_FRAMEINTERVALS).stepwise", data->stepwise); + break; + } + case VKI_V4L2_G_ENC_INDEX: { + struct vki_v4l2_enc_idx *data = (struct vki_v4l2_enc_idx *)ARG3; + PRE_MEM_READ("ioctl(VKI_V4L2_G_ENC_INDEX)", (Addr)data, sizeof(*data)); + break; + } + case VKI_V4L2_ENCODER_CMD: { + struct vki_v4l2_encoder_cmd *data = (struct vki_v4l2_encoder_cmd *)ARG3; + PRE_MEM_READ("ioctl(VKI_V4L2_ENCODER_CMD)", (Addr)data, sizeof(*data)); + break; + } + case VKI_V4L2_TRY_ENCODER_CMD: { + struct vki_v4l2_encoder_cmd *data = (struct vki_v4l2_encoder_cmd *)ARG3; + PRE_MEM_READ("ioctl(VKI_V4L2_TRY_ENCODER_CMD)", (Addr)data, sizeof(*data)); + break; + } + case VKI_V4L2_DBG_S_REGISTER: { + struct vki_v4l2_dbg_register *data = (struct vki_v4l2_dbg_register *)ARG3; + PRE_FIELD_READ("ioctl(VKI_V4L2_DBG_S_REGISTER).match.type", data->match.type); + PRE_FIELD_READ("ioctl(VKI_V4L2_DBG_S_REGISTER).match.addr", data->match.addr); + PRE_FIELD_READ("ioctl(VKI_V4L2_DBG_S_REGISTER).reg", data->reg); + PRE_FIELD_READ("ioctl(VKI_V4L2_DBG_S_REGISTER).val", data->val); + PRE_FIELD_WRITE("ioctl(VKI_V4L2_DBG_S_REGISTER).size", data->size); + break; + } + case VKI_V4L2_DBG_G_REGISTER: { + struct vki_v4l2_dbg_register *data = (struct vki_v4l2_dbg_register *)ARG3; + PRE_FIELD_READ("ioctl(VKI_V4L2_DBG_G_REGISTER).match.type", data->match.type); + PRE_FIELD_READ("ioctl(VKI_V4L2_DBG_G_REGISTER).match.addr", data->match.addr); + PRE_FIELD_READ("ioctl(VKI_V4L2_DBG_G_REGISTER).reg", data->reg); + PRE_FIELD_WRITE("ioctl(VKI_V4L2_DBG_G_REGISTER).val", data->val); + PRE_FIELD_WRITE("ioctl(VKI_V4L2_DBG_G_REGISTER).size", data->size); + break; + } + case VKI_V4L2_S_HW_FREQ_SEEK: { + struct vki_v4l2_hw_freq_seek *data = (struct vki_v4l2_hw_freq_seek *)ARG3; + PRE_MEM_READ("ioctl(VKI_V4L2_S_HW_FREQ_SEEK)", (Addr)data, sizeof(*data)); + break; + } + case VKI_V4L2_S_DV_TIMINGS: { + struct vki_v4l2_dv_timings *data = (struct vki_v4l2_dv_timings *)ARG3; + PRE_FIELD_READ("ioctl(VKI_V4L2_S_DV_TIMINGS).type", data->type); + PRE_FIELD_READ("ioctl(VKI_V4L2_S_DV_TIMINGS).bt", data->bt); + break; + } + case VKI_V4L2_G_DV_TIMINGS: { + struct vki_v4l2_dv_timings *data = (struct vki_v4l2_dv_timings *)ARG3; + PRE_MEM_WRITE("ioctl(VKI_V4L2_G_DV_TIMINGS)", (Addr)data, sizeof(*data)); + break; + } + case VKI_V4L2_DQEVENT: { + struct vki_v4l2_event *data = (struct vki_v4l2_event *)ARG3; + PRE_MEM_WRITE("ioctl(VKI_V4L2_DQEVENT)", (Addr)data, sizeof(*data)); + break; + } + case VKI_V4L2_SUBSCRIBE_EVENT: { + struct vki_v4l2_event_subscription *data = (struct vki_v4l2_event_subscription *)ARG3; + PRE_MEM_READ("ioctl(VKI_V4L2_SUBSCRIBE_EVENT)", (Addr)data, sizeof(*data)); + break; + } + case VKI_V4L2_UNSUBSCRIBE_EVENT: { + struct vki_v4l2_event_subscription *data = (struct vki_v4l2_event_subscription *)ARG3; + PRE_MEM_READ("ioctl(VKI_V4L2_UNSUBSCRIBE_EVENT)", (Addr)data, sizeof(*data)); + break; + } + case VKI_V4L2_CREATE_BUFS: { + struct vki_v4l2_create_buffers *data = (struct vki_v4l2_create_buffers *)ARG3; + struct vki_v4l2_format *fmt = &data->format; + PRE_FIELD_WRITE("ioctl(VKI_V4L2_CREATE_BUFS).index", data->index); + PRE_FIELD_READ("ioctl(VKI_V4L2_CREATE_BUFS).count", data->count); + PRE_FIELD_READ("ioctl(VKI_V4L2_CREATE_BUFS).memory", data->memory); + PRE_FIELD_READ("ioctl(VKI_V4L2_CREATE_BUFS).reserved", data->reserved); + PRE_FIELD_READ("ioctl(VKI_V4L2_CREATE_BUFS).format.type", fmt->type); + switch (fmt->type) { + case VKI_V4L2_BUF_TYPE_VIDEO_CAPTURE: + case VKI_V4L2_BUF_TYPE_VIDEO_OUTPUT: + PRE_FIELD_READ("ioctl(VKI_V4L2_CREATE_BUFS).format.pix", fmt->fmt.raw_data); + break; + case VKI_V4L2_BUF_TYPE_VBI_CAPTURE: + case VKI_V4L2_BUF_TYPE_VBI_OUTPUT: + PRE_FIELD_READ("ioctl(VKI_V4L2_CREATE_BUFS).format.vbi", fmt->fmt.vbi); + break; + case VKI_V4L2_BUF_TYPE_SLICED_VBI_CAPTURE: + case VKI_V4L2_BUF_TYPE_SLICED_VBI_OUTPUT: + PRE_FIELD_READ("ioctl(VKI_V4L2_CREATE_BUFS).format.sliced", fmt->fmt.sliced); + break; + case VKI_V4L2_BUF_TYPE_VIDEO_OVERLAY: + case VKI_V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY: + PRE_FIELD_READ("ioctl(VKI_V4L2_CREATE_BUFS).format.win", fmt->fmt.win); + break; + case VKI_V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE: + case VKI_V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE: + PRE_FIELD_READ("ioctl(VKI_V4L2_CREATE_BUFS).format.pix_mp", fmt->fmt.pix_mp); + break; + case VKI_V4L2_BUF_TYPE_SDR_CAPTURE: + PRE_FIELD_READ("ioctl(VKI_V4L2_CREATE_BUFS).format.sdr", fmt->fmt.sdr); + break; + } + break; + } + case VKI_V4L2_PREPARE_BUF: { + struct vki_v4l2_buffer *data = (struct vki_v4l2_buffer *)ARG3; + PRE_FIELD_READ("ioctl(VKI_V4L2_PREPARE_BUF).index", data->index); + PRE_FIELD_READ("ioctl(VKI_V4L2_PREPARE_BUF).type", data->type); + PRE_FIELD_READ("ioctl(VKI_V4L2_PREPARE_BUF).memory", data->memory); + PRE_FIELD_READ("ioctl(VKI_V4L2_PREPARE_BUF).reserved", data->reserved); + PRE_FIELD_READ("ioctl(VKI_V4L2_PREPARE_BUF).reserved2", data->reserved2); + if (data->type == VKI_V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE || + data->type == VKI_V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE) { + unsigned i; + + PRE_FIELD_READ("ioctl(VKI_V4L2_PREPARE_BUF).length", data->length); + PRE_FIELD_READ("ioctl(VKI_V4L2_PREPARE_BUF).m.planes", data->m.planes); + for (i = 0; i < data->length; i++) { + PRE_FIELD_READ("ioctl(VKI_V4L2_PREPARE_BUF).m.planes[].reserved", data->m.planes[i].reserved); + } + } + break; + } + case VKI_V4L2_G_SELECTION: { + struct vki_v4l2_selection *data = (struct vki_v4l2_selection *)ARG3; + PRE_FIELD_READ("ioctl(VKI_V4L2_G_SELECTION).type", data->type); + PRE_FIELD_READ("ioctl(VKI_V4L2_G_SELECTION).target", data->target); + PRE_FIELD_READ("ioctl(VKI_V4L2_G_SELECTION).flags", data->flags); + PRE_FIELD_READ("ioctl(VKI_V4L2_G_SELECTION).reserved", data->reserved); + PRE_FIELD_WRITE("ioctl(VKI_V4L2_G_SELECTION).r", data->r); + break; + } + case VKI_V4L2_S_SELECTION: { + struct vki_v4l2_selection *data = (struct vki_v4l2_selection *)ARG3; + PRE_MEM_READ("ioctl(VKI_V4L2_S_SELECTION)", (Addr)data, sizeof(*data)); + break; + } + case VKI_V4L2_DECODER_CMD: { + struct vki_v4l2_decoder_cmd *data = (struct vki_v4l2_decoder_cmd *)ARG3; + PRE_MEM_READ("ioctl(VKI_V4L2_DECODER_CMD)", (Addr)data, sizeof(*data)); + break; + } + case VKI_V4L2_TRY_DECODER_CMD: { + struct vki_v4l2_decoder_cmd *data = (struct vki_v4l2_decoder_cmd *)ARG3; + PRE_MEM_READ("ioctl(VKI_V4L2_TRY_DECODER_CMD)", (Addr)data, sizeof(*data)); + break; + } + case VKI_V4L2_ENUM_DV_TIMINGS: { + struct vki_v4l2_enum_dv_timings *data = (struct vki_v4l2_enum_dv_timings *)ARG3; + PRE_FIELD_READ("ioctl(VKI_V4L2_ENUM_DV_TIMINGS).index", data->index); + PRE_FIELD_READ("ioctl(VKI_V4L2_ENUM_DV_TIMINGS).pad", data->pad); + PRE_FIELD_READ("ioctl(VKI_V4L2_ENUM_DV_TIMINGS).reserved", data->reserved); + PRE_FIELD_WRITE("ioctl(VKI_V4L2_ENUM_DV_TIMINGS).timings", data->timings); + break; + } + case VKI_V4L2_QUERY_DV_TIMINGS: { + struct vki_v4l2_dv_timings *data = (struct vki_v4l2_dv_timings *)ARG3; + PRE_MEM_WRITE("ioctl(VKI_V4L2_QUERY_DV_TIMINGS)", (Addr)data, sizeof(*data)); + break; + } + case VKI_V4L2_DV_TIMINGS_CAP: { + struct vki_v4l2_dv_timings_cap *data = (struct vki_v4l2_dv_timings_cap *)ARG3; + PRE_MEM_WRITE("ioctl(VKI_V4L2_DV_TIMINGS_CAP)", (Addr)data, sizeof(*data)); + break; + } + case VKI_V4L2_ENUM_FREQ_BANDS: { + struct vki_v4l2_frequency_band *data = (struct vki_v4l2_frequency_band *)ARG3; + PRE_FIELD_READ("ioctl(VKI_V4L2_ENUM_FREQ_BANDS).tuner", data->tuner); + PRE_FIELD_READ("ioctl(VKI_V4L2_ENUM_FREQ_BANDS).type", data->type); + PRE_FIELD_READ("ioctl(VKI_V4L2_ENUM_FREQ_BANDS).index", data->index); + PRE_FIELD_READ("ioctl(VKI_V4L2_ENUM_FREQ_BANDS).reserved", data->reserved); + PRE_FIELD_WRITE("ioctl(VKI_V4L2_ENUM_FREQ_BANDS).capability", data->capability); + PRE_FIELD_WRITE("ioctl(VKI_V4L2_ENUM_FREQ_BANDS).rangelow", data->rangelow); + PRE_FIELD_WRITE("ioctl(VKI_V4L2_ENUM_FREQ_BANDS).rangehigh", data->rangehigh); + PRE_FIELD_WRITE("ioctl(VKI_V4L2_ENUM_FREQ_BANDS).modulation", data->modulation); + break; + } + case VKI_V4L2_DBG_G_CHIP_INFO: { + struct vki_v4l2_dbg_chip_info *data = (struct vki_v4l2_dbg_chip_info *)ARG3; + PRE_FIELD_READ("ioctl(VKI_V4L2_DBG_G_CHIP_INFO).match.type", data->match.type); + PRE_FIELD_READ("ioctl(VKI_V4L2_DBG_G_CHIP_INFO).match.addr", data->match.addr); + PRE_FIELD_WRITE("ioctl(VKI_V4L2_DBG_G_CHIP_INFO).name", data->name); + PRE_FIELD_WRITE("ioctl(VKI_V4L2_DBG_G_CHIP_INFO).flags", data->flags); + PRE_FIELD_READ("ioctl(VKI_V4L2_DBG_G_CHIP_INFO).reserved", data->reserved); + break; + } + case VKI_V4L2_QUERY_EXT_CTRL: { + struct vki_v4l2_query_ext_ctrl *data = (struct vki_v4l2_query_ext_ctrl *)ARG3; + PRE_FIELD_READ("ioctl(VKI_V4L2_QUERY_EXT_CTRL).id", data->id); + PRE_FIELD_READ("ioctl(VKI_V4L2_QUERY_EXT_CTRL).reserved", data->reserved); + PRE_MEM_WRITE("ioctl(VKI_V4L2_QUERY_EXT_CTRL)", (Addr)&data->type, + sizeof(*data) - sizeof(data->id) - sizeof(data->reserved)); + break; + } + case VKI_V4L2_SUBDEV_G_FMT: { + struct vki_v4l2_subdev_format *data = (struct vki_v4l2_subdev_format *)ARG3; + PRE_FIELD_READ("ioctl(VKI_V4L2_SUBDEV_G_FMT).pad", data->pad); + PRE_FIELD_READ("ioctl(VKI_V4L2_SUBDEV_G_FMT).which", data->which); + PRE_FIELD_READ("ioctl(VKI_V4L2_SUBDEV_G_FMT).reserved", data->reserved); + PRE_FIELD_WRITE("ioctl(VKI_V4L2_SUBDEV_G_FMT).format", data->format); + break; + } + case VKI_V4L2_SUBDEV_S_FMT: { + struct vki_v4l2_subdev_format *data = (struct vki_v4l2_subdev_format *)ARG3; + PRE_MEM_READ("ioctl(VKI_V4L2_SUBDEV_S_FMT)", (Addr)data, sizeof(*data)); + break; + } + case VKI_V4L2_SUBDEV_G_FRAME_INTERVAL: { + struct vki_v4l2_subdev_frame_interval *data = (struct vki_v4l2_subdev_frame_interval *)ARG3; + PRE_FIELD_READ("ioctl(VKI_V4L2_SUBDEV_G_FRAME_SIZE).pad", data->pad); + PRE_FIELD_READ("ioctl(VKI_V4L2_SUBDEV_G_FRAME_SIZE).reserved", data->reserved); + PRE_FIELD_WRITE("ioctl(VKI_V4L2_SUBDEV_G_FRAME_SIZE).interval", data->interval); + break; + } + case VKI_V4L2_SUBDEV_S_FRAME_INTERVAL: { + struct vki_v4l2_subdev_frame_interval *data = (struct vki_v4l2_subdev_frame_interval *)ARG3; + PRE_MEM_READ("ioctl(VKI_V4L2_SUBDEV_S_FRAME_INTERVAL)", (Addr)data, sizeof(*data)); + break; + } + case VKI_V4L2_SUBDEV_ENUM_MBUS_CODE: { + struct vki_v4l2_subdev_mbus_code_enum *data = (struct vki_v4l2_subdev_mbus_code_enum *)ARG3; + PRE_FIELD_READ("ioctl(VKI_V4L2_SUBDEV_ENUM_MBUS_CODE).index", data->index); + PRE_FIELD_READ("ioctl(VKI_V4L2_SUBDEV_ENUM_MBUS_CODE).pad", data->pad); + PRE_FIELD_WRITE("ioctl(VKI_V4L2_SUBDEV_ENUM_MBUS_CODE).code", data->code); + PRE_FIELD_READ("ioctl(VKI_V4L2_SUBDEV_ENUM_MBUS_CODE).reserved", data->reserved); + break; + } + case VKI_V4L2_SUBDEV_ENUM_FRAME_SIZE: { + struct vki_v4l2_subdev_frame_size_enum *data = (struct vki_v4l2_subdev_frame_size_enum *)ARG3; + PRE_FIELD_READ("ioctl(VKI_V4L2_SUBDEV_ENUM_FRAME_SIZE).index", data->index); + PRE_FIELD_READ("ioctl(VKI_V4L2_SUBDEV_ENUM_FRAME_SIZE).pad", data->pad); + PRE_FIELD_READ("ioctl(VKI_V4L2_SUBDEV_ENUM_FRAME_SIZE).code", data->code); + PRE_FIELD_READ("ioctl(VKI_V4L2_SUBDEV_ENUM_FRAME_SIZE).reserved", data->reserved); + PRE_FIELD_WRITE("ioctl(VKI_V4L2_SUBDEV_ENUM_FRAME_SIZE).min_width", data->min_width); + PRE_FIELD_WRITE("ioctl(VKI_V4L2_SUBDEV_ENUM_FRAME_SIZE).min_height", data->min_height); + PRE_FIELD_WRITE("ioctl(VKI_V4L2_SUBDEV_ENUM_FRAME_SIZE).max_width", data->max_width); + PRE_FIELD_WRITE("ioctl(VKI_V4L2_SUBDEV_ENUM_FRAME_SIZE).max_height", data->max_height); + break; + } + case VKI_V4L2_SUBDEV_ENUM_FRAME_INTERVAL: { + struct vki_v4l2_subdev_frame_interval_enum *data = (struct vki_v4l2_subdev_frame_interval_enum *)ARG3; + PRE_FIELD_READ("ioctl(VKI_V4L2_SUBDEV_ENUM_FRAME_INTERVAL).index", data->index); + PRE_FIELD_READ("ioctl(VKI_V4L2_SUBDEV_ENUM_FRAME_INTERVAL).pad", data->pad); + PRE_FIELD_READ("ioctl(VKI_V4L2_SUBDEV_ENUM_FRAME_INTERVAL).code", data->code); + PRE_FIELD_READ("ioctl(VKI_V4L2_SUBDEV_ENUM_FRAME_INTERVAL).width", data->width); + PRE_FIELD_READ("ioctl(VKI_V4L2_SUBDEV_ENUM_FRAME_INTERVAL).height", data->height); + PRE_FIELD_READ("ioctl(VKI_V4L2_SUBDEV_ENUM_FRAME_INTERVAL).reserved", data->reserved); + PRE_FIELD_WRITE("ioctl(VKI_V4L2_SUBDEV_ENUM_FRAME_INTERVAL).interval", data->interval); + break; + } + case VKI_V4L2_SUBDEV_G_CROP: { + struct vki_v4l2_subdev_crop *data = (struct vki_v4l2_subdev_crop *)ARG3; + PRE_FIELD_READ("ioctl(VKI_V4L2_SUBDEV_G_CROP).pad", data->pad); + PRE_FIELD_READ("ioctl(VKI_V4L2_SUBDEV_G_CROP).which", data->which); + PRE_FIELD_READ("ioctl(VKI_V4L2_SUBDEV_G_CROP).reserved", data->reserved); + PRE_FIELD_WRITE("ioctl(VKI_V4L2_SUBDEV_G_CROP).rect", data->rect); + break; + } + case VKI_V4L2_SUBDEV_S_CROP: { + struct vki_v4l2_subdev_crop *data = (struct vki_v4l2_subdev_crop *)ARG3; + PRE_MEM_READ("ioctl(VKI_V4L2_SUBDEV_S_CROP)", (Addr)data, sizeof(*data)); + break; + } + case VKI_V4L2_SUBDEV_G_SELECTION: { + struct vki_v4l2_subdev_selection *data = (struct vki_v4l2_subdev_selection *)ARG3; + PRE_FIELD_READ("ioctl(VKI_V4L2_SUBDEV_G_SELECTION).pad", data->pad); + PRE_FIELD_READ("ioctl(VKI_V4L2_SUBDEV_G_SELECTION).which", data->which); + PRE_FIELD_READ("ioctl(VKI_V4L2_SUBDEV_G_SELECTION).target", data->target); + PRE_FIELD_READ("ioctl(VKI_V4L2_SUBDEV_G_SELECTION).flags", data->flags); + PRE_FIELD_READ("ioctl(VKI_V4L2_SUBDEV_G_SELECTION).reserved", data->reserved); + PRE_FIELD_WRITE("ioctl(VKI_V4L2_SUBDEV_G_SELECTION).r", data->r); + break; + } + case VKI_V4L2_SUBDEV_S_SELECTION: { + struct vki_v4l2_subdev_selection *data = (struct vki_v4l2_subdev_selection *)ARG3; + PRE_MEM_READ("ioctl(VKI_V4L2_SUBDEV_S_SELECTION)", (Addr)data, sizeof(*data)); + break; + } + case VKI_MEDIA_IOC_DEVICE_INFO: { + struct vki_media_device_info *data = (struct vki_media_device_info *)ARG3; + PRE_FIELD_READ("ioctl(VKI_MEDIA_IOC_DEVICE_INFO).reserved", data->reserved); + PRE_MEM_WRITE("ioctl(VKI_MEDIA_IOC_DEVICE_INFO)", + (Addr)data, sizeof(*data) - sizeof(data->reserved)); + break; + } + case VKI_MEDIA_IOC_ENUM_ENTITIES: { + struct vki_media_entity_desc *data = (struct vki_media_entity_desc *)ARG3; + PRE_FIELD_READ("ioctl(VKI_MEDIA_IOC_ENUM_ENTITIES).id", data->id); + PRE_MEM_WRITE("ioctl(VKI_MEDIA_IOC_ENUM_ENTITIES)", + (Addr)data->name, sizeof(*data) - sizeof(data->id)); + break; + } + case VKI_MEDIA_IOC_ENUM_LINKS: { + struct vki_media_links_enum *data = (struct vki_media_links_enum *)ARG3; + PRE_MEM_READ("ioctl(VKI_MEDIA_IOC_ENUM_LINKS)", (Addr)data, sizeof(*data)); + break; + } + case VKI_MEDIA_IOC_SETUP_LINK: { + struct vki_media_link_desc *data = (struct vki_media_link_desc *)ARG3; + PRE_MEM_READ("ioctl(VKI_MEDIA_IOC_SETUP_LINK)", (Addr)data, sizeof(*data)); + break; + } + default: /* EVIOC* are variable length and return size written on success */ switch (ARG2 & ~(_VKI_IOC_SIZEMASK << _VKI_IOC_SIZESHIFT)) { @@ -8463,6 +9416,498 @@ POST(sys_ioctl) } break; + /* V4L2 */ + case VKI_V4L2_S_FMT: + case VKI_V4L2_TRY_FMT: + case VKI_V4L2_REQBUFS: + case VKI_V4L2_OVERLAY: + case VKI_V4L2_STREAMON: + case VKI_V4L2_STREAMOFF: + case VKI_V4L2_S_PARM: + case VKI_V4L2_S_STD: + case VKI_V4L2_S_FREQUENCY: + case VKI_V4L2_S_CTRL: + case VKI_V4L2_S_TUNER: + case VKI_V4L2_S_AUDIO: + case VKI_V4L2_S_INPUT: + case VKI_V4L2_S_EDID: + case VKI_V4L2_S_OUTPUT: + case VKI_V4L2_S_AUDOUT: + case VKI_V4L2_S_MODULATOR: + case VKI_V4L2_S_JPEGCOMP: + case VKI_V4L2_S_CROP: + case VKI_V4L2_S_PRIORITY: + case VKI_V4L2_G_ENC_INDEX: + case VKI_V4L2_S_HW_FREQ_SEEK: + case VKI_V4L2_S_DV_TIMINGS: + case VKI_V4L2_SUBSCRIBE_EVENT: + case VKI_V4L2_UNSUBSCRIBE_EVENT: + case VKI_V4L2_PREPARE_BUF: + break; + case VKI_V4L2_QUERYCAP: { + struct vki_v4l2_capability *data = (struct vki_v4l2_capability *)ARG3; + POST_MEM_WRITE((Addr)data, sizeof(*data)); + break; + } + case VKI_V4L2_ENUM_FMT: { + struct vki_v4l2_fmtdesc *data = (struct vki_v4l2_fmtdesc *)ARG3; + POST_FIELD_WRITE(data->flags); + POST_FIELD_WRITE(data->description); + POST_FIELD_WRITE(data->pixelformat); + POST_FIELD_WRITE(data->reserved); + break; + } + case VKI_V4L2_G_FMT: { + struct vki_v4l2_format *data = (struct vki_v4l2_format *)ARG3; + switch (data->type) { + case VKI_V4L2_BUF_TYPE_VIDEO_CAPTURE: + case VKI_V4L2_BUF_TYPE_VIDEO_OUTPUT: + POST_FIELD_WRITE(data->fmt.pix); + break; + case VKI_V4L2_BUF_TYPE_VBI_CAPTURE: + case VKI_V4L2_BUF_TYPE_VBI_OUTPUT: + POST_FIELD_WRITE(data->fmt.vbi); + break; + case VKI_V4L2_BUF_TYPE_SLICED_VBI_CAPTURE: + case VKI_V4L2_BUF_TYPE_SLICED_VBI_OUTPUT: + POST_FIELD_WRITE(data->fmt.sliced); + break; + case VKI_V4L2_BUF_TYPE_VIDEO_OVERLAY: + case VKI_V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY: + POST_FIELD_WRITE(data->fmt.win); + break; + case VKI_V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE: + case VKI_V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE: + POST_FIELD_WRITE(data->fmt.pix_mp); + break; + case VKI_V4L2_BUF_TYPE_SDR_CAPTURE: + POST_FIELD_WRITE(data->fmt.sdr); + break; + } + break; + } + case VKI_V4L2_QUERYBUF: { + struct vki_v4l2_buffer *data = (struct vki_v4l2_buffer *)ARG3; + if (data->type == VKI_V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE || + data->type == VKI_V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE) { + unsigned i; + + for (i = 0; i < data->length; i++) { + POST_FIELD_WRITE(data->m.planes[i].bytesused); + POST_FIELD_WRITE(data->m.planes[i].length); + POST_FIELD_WRITE(data->m.planes[i].m); + POST_FIELD_WRITE(data->m.planes[i].data_offset); + POST_FIELD_WRITE(data->m.planes[i].reserved); + } + } else { + POST_FIELD_WRITE(data->m); + POST_FIELD_WRITE(data->length); + } + POST_FIELD_WRITE(data->bytesused); + POST_FIELD_WRITE(data->flags); + POST_FIELD_WRITE(data->field); + POST_FIELD_WRITE(data->timestamp); + POST_FIELD_WRITE(data->timecode); + POST_FIELD_WRITE(data->sequence); + POST_FIELD_WRITE(data->memory); + POST_FIELD_WRITE(data->sequence); + break; + } + case VKI_V4L2_G_FBUF: { + struct vki_v4l2_framebuffer *data = (struct vki_v4l2_framebuffer *)ARG3; + POST_MEM_WRITE((Addr)data, sizeof(*data)); + break; + } + case VKI_V4L2_S_FBUF: { + struct vki_v4l2_framebuffer *data = (struct vki_v4l2_framebuffer *)ARG3; + POST_FIELD_WRITE(data->capability); + POST_FIELD_WRITE(data->flags); + POST_FIELD_WRITE(data->fmt); + break; + } + case VKI_V4L2_QBUF: { + struct vki_v4l2_buffer *data = (struct vki_v4l2_buffer *)ARG3; + + if (data->type == VKI_V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE || + data->type == VKI_V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE) { + unsigned i; + + for (i = 0; i < data->length; i++) { + POST_FIELD_WRITE(data->m.planes[i].length); + if (data->memory == VKI_V4L2_MEMORY_MMAP) + POST_FIELD_WRITE(data->m.planes[i].m); + } + } else { + if (data->memory == VKI_V4L2_MEMORY_MMAP) + POST_FIELD_WRITE(data->m); + POST_FIELD_WRITE(data->length); + } + break; + } + case VKI_V4L2_EXPBUF: { + struct vki_v4l2_exportbuffer *data = (struct vki_v4l2_exportbuffer *)ARG3; + POST_FIELD_WRITE(data->fd); + break; + } + case VKI_V4L2_DQBUF: { + struct vki_v4l2_buffer *data = (struct vki_v4l2_buffer *)ARG3; + POST_FIELD_WRITE(data->index); + POST_FIELD_WRITE(data->bytesused); + POST_FIELD_WRITE(data->field); + if (data->type == VKI_V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE || + data->type == VKI_V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE) { + unsigned i; + + for (i = 0; i < data->length; i++) { + POST_FIELD_WRITE(data->m.planes[i].bytesused); + POST_FIELD_WRITE(data->m.planes[i].data_offset); + POST_FIELD_WRITE(data->m.planes[i].length); + POST_FIELD_WRITE(data->m.planes[i].m); + } + } else { + POST_FIELD_WRITE(data->m); + POST_FIELD_WRITE(data->length); + POST_FIELD_WRITE(data->bytesused); + POST_FIELD_WRITE(data->field); + } + POST_FIELD_WRITE(data->timestamp); + POST_FIELD_WRITE(data->timecode); + POST_FIELD_WRITE(data->sequence); + break; + } + case VKI_V4L2_G_PARM: { + struct vki_v4l2_streamparm *data = (struct vki_v4l2_streamparm *)ARG3; + int is_output = data->type == VKI_V4L2_BUF_TYPE_VIDEO_OUTPUT || + data->type == VKI_V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE || + data->type == VKI_V4L2_BUF_TYPE_VBI_OUTPUT || + data->type == VKI_V4L2_BUF_TYPE_SLICED_VBI_OUTPUT; + + if (is_output) + POST_MEM_WRITE((Addr)&data->parm.output, + sizeof(data->parm.output) - sizeof(data->parm.output.reserved)); + else + POST_MEM_WRITE((Addr)&data->parm.capture, + sizeof(data->parm.capture) - sizeof(data->parm.capture.reserved)); + break; + } + case VKI_V4L2_G_STD: { + vki_v4l2_std_id *data = (vki_v4l2_std_id *)ARG3; + POST_MEM_WRITE((Addr)data, sizeof(*data)); + break; + } + case VKI_V4L2_ENUMSTD: { + struct vki_v4l2_standard *data = (struct vki_v4l2_standard *)ARG3; + POST_MEM_WRITE((Addr)&data->id, sizeof(*data) - sizeof(data->index)); + break; + } + case VKI_V4L2_ENUMINPUT: { + struct vki_v4l2_input *data = (struct vki_v4l2_input *)ARG3; + POST_MEM_WRITE((Addr)data->name, sizeof(*data) - sizeof(data->index)); + break; + } + case VKI_V4L2_G_CTRL: { + struct vki_v4l2_control *data = (struct vki_v4l2_control *)ARG3; + POST_FIELD_WRITE(data->value); + break; + } + case VKI_V4L2_G_TUNER: { + struct vki_v4l2_tuner *data = (struct vki_v4l2_tuner *)ARG3; + POST_MEM_WRITE((Addr)data->name, + sizeof(*data) - sizeof(data->index) - sizeof(data->reserved)); + break; + } + case VKI_V4L2_G_AUDIO: { + struct vki_v4l2_audio *data = (struct vki_v4l2_audio *)ARG3; + POST_MEM_WRITE((Addr)data->name, + sizeof(*data) - sizeof(data->index) - sizeof(data->reserved)); + break; + } + case VKI_V4L2_QUERYCTRL: { + struct vki_v4l2_queryctrl *data = (struct vki_v4l2_queryctrl *)ARG3; + POST_MEM_WRITE((Addr)&data->type, + sizeof(*data) - sizeof(data->id)); + break; + } + case VKI_V4L2_QUERYMENU: { + struct vki_v4l2_querymenu *data = (struct vki_v4l2_querymenu *)ARG3; + POST_MEM_WRITE((Addr)data->name, + sizeof(*data) - sizeof(data->id) - sizeof(data->index)); + break; + } + case VKI_V4L2_G_INPUT: { + int *data = (int *)ARG3; + POST_MEM_WRITE((Addr)data, sizeof(*data)); + break; + } + case VKI_V4L2_G_EDID: { + struct vki_v4l2_edid *data = (struct vki_v4l2_edid *)ARG3; + if (data->blocks && data->edid) + POST_MEM_WRITE((Addr)data->edid, data->blocks * 128); + break; + } + case VKI_V4L2_G_OUTPUT: { + int *data = (int *)ARG3; + POST_MEM_WRITE((Addr)data, sizeof(*data)); + break; + } + case VKI_V4L2_ENUMOUTPUT: { + struct vki_v4l2_output *data = (struct vki_v4l2_output *)ARG3; + POST_MEM_WRITE((Addr)data->name, sizeof(*data) - sizeof(data->index)); + break; + } + case VKI_V4L2_G_AUDOUT: { + struct vki_v4l2_audioout *data = (struct vki_v4l2_audioout *)ARG3; + POST_MEM_WRITE((Addr)data->name, + sizeof(*data) - sizeof(data->index) - sizeof(data->reserved)); + break; + } + case VKI_V4L2_G_MODULATOR: { + struct vki_v4l2_modulator *data = (struct vki_v4l2_modulator *)ARG3; + POST_MEM_WRITE((Addr)data->name, + sizeof(*data) - sizeof(data->index) - sizeof(data->reserved)); + break; + } + case VKI_V4L2_G_FREQUENCY: { + struct vki_v4l2_frequency *data = (struct vki_v4l2_frequency *)ARG3; + POST_FIELD_WRITE(data->type); + POST_FIELD_WRITE(data->frequency); + break; + } + case VKI_V4L2_CROPCAP: { + struct vki_v4l2_cropcap *data = (struct vki_v4l2_cropcap *)ARG3; + POST_MEM_WRITE((Addr)&data->bounds, sizeof(*data) - sizeof(data->type)); + break; + } + case VKI_V4L2_G_CROP: { + struct vki_v4l2_crop *data = (struct vki_v4l2_crop *)ARG3; + POST_FIELD_WRITE(data->c); + break; + } + case VKI_V4L2_G_JPEGCOMP: { + struct vki_v4l2_jpegcompression *data = (struct vki_v4l2_jpegcompression *)ARG3; + POST_MEM_WRITE((Addr)data, sizeof(*data)); + break; + } + case VKI_V4L2_QUERYSTD: { + vki_v4l2_std_id *data = (vki_v4l2_std_id *)ARG3; + POST_MEM_WRITE((Addr)data, sizeof(*data)); + break; + } + case VKI_V4L2_ENUMAUDIO: { + struct vki_v4l2_audio *data = (struct vki_v4l2_audio *)ARG3; + POST_MEM_WRITE((Addr)data->name, + sizeof(*data) - sizeof(data->index) - sizeof(data->reserved)); + break; + } + case VKI_V4L2_ENUMAUDOUT: { + struct vki_v4l2_audioout *data = (struct vki_v4l2_audioout *)ARG3; + POST_MEM_WRITE((Addr)data->name, + sizeof(*data) - sizeof(data->index) - sizeof(data->reserved)); + break; + } + case VKI_V4L2_G_PRIORITY: { + __vki_u32 *data = (__vki_u32 *)ARG3; + POST_MEM_WRITE((Addr)data, sizeof(*data)); + break; + } + case VKI_V4L2_G_SLICED_VBI_CAP: { + struct vki_v4l2_sliced_vbi_cap *data = (struct vki_v4l2_sliced_vbi_cap *)ARG3; + POST_MEM_WRITE((Addr)data, + sizeof(*data) - sizeof(data->type) - sizeof(data->reserved)); + break; + } + case VKI_V4L2_G_EXT_CTRLS: { + struct vki_v4l2_ext_controls *data = (struct vki_v4l2_ext_controls *)ARG3; + if (data->count) { + unsigned i; + + for (i = 0; i < data->count; i++) { + if (data->controls[i].size) + POST_MEM_WRITE((Addr)data->controls[i].ptr, data->controls[i].size); + else + POST_FIELD_WRITE(data->controls[i].value64); + } + } + POST_FIELD_WRITE(data->error_idx); + break; + } + case VKI_V4L2_S_EXT_CTRLS: { + struct vki_v4l2_ext_controls *data = (struct vki_v4l2_ext_controls *)ARG3; + POST_FIELD_WRITE(data->error_idx); + break; + } + case VKI_V4L2_TRY_EXT_CTRLS: { + struct vki_v4l2_ext_controls *data = (struct vki_v4l2_ext_controls *)ARG3; + POST_FIELD_WRITE(data->error_idx); + break; + } + case VKI_V4L2_ENUM_FRAMESIZES: { + struct vki_v4l2_frmsizeenum *data = (struct vki_v4l2_frmsizeenum *)ARG3; + POST_FIELD_WRITE(data->type); + POST_FIELD_WRITE(data->stepwise); + break; + } + case VKI_V4L2_ENUM_FRAMEINTERVALS: { + struct vki_v4l2_frmivalenum *data = (struct vki_v4l2_frmivalenum *)ARG3; + POST_FIELD_WRITE(data->type); + POST_FIELD_WRITE(data->stepwise); + break; + } + case VKI_V4L2_ENCODER_CMD: { + struct vki_v4l2_encoder_cmd *data = (struct vki_v4l2_encoder_cmd *)ARG3; + POST_FIELD_WRITE(data->flags); + break; + } + case VKI_V4L2_TRY_ENCODER_CMD: { + struct vki_v4l2_encoder_cmd *data = (struct vki_v4l2_encoder_cmd *)ARG3; + POST_FIELD_WRITE(data->flags); + break; + } + case VKI_V4L2_DBG_S_REGISTER: { + struct vki_v4l2_dbg_register *data = (struct vki_v4l2_dbg_register *)ARG3; + POST_FIELD_WRITE(data->size); + break; + } + case VKI_V4L2_DBG_G_REGISTER: { + struct vki_v4l2_dbg_register *data = (struct vki_v4l2_dbg_register *)ARG3; + POST_FIELD_WRITE(data->val); + POST_FIELD_WRITE(data->size); + break; + } + case VKI_V4L2_G_DV_TIMINGS: { + struct vki_v4l2_dv_timings *data = (struct vki_v4l2_dv_timings *)ARG3; + POST_MEM_WRITE((Addr)data, sizeof(*data)); + break; + } + case VKI_V4L2_DQEVENT: { + struct vki_v4l2_event *data = (struct vki_v4l2_event *)ARG3; + POST_MEM_WRITE((Addr)data, sizeof(*data)); + break; + } + case VKI_V4L2_CREATE_BUFS: { + struct vki_v4l2_create_buffers *data = (struct vki_v4l2_create_buffers *)ARG3; + POST_FIELD_WRITE(data->index); + break; + } + case VKI_V4L2_G_SELECTION: { + struct vki_v4l2_selection *data = (struct vki_v4l2_selection *)ARG3; + POST_FIELD_WRITE(data->r); + break; + } + case VKI_V4L2_S_SELECTION: { + struct vki_v4l2_selection *data = (struct vki_v4l2_selection *)ARG3; + POST_FIELD_WRITE(data->r); + break; + } + case VKI_V4L2_DECODER_CMD: { + struct vki_v4l2_decoder_cmd *data = (struct vki_v4l2_decoder_cmd *)ARG3; + POST_FIELD_WRITE(data->flags); + break; + } + case VKI_V4L2_TRY_DECODER_CMD: { + struct vki_v4l2_decoder_cmd *data = (struct vki_v4l2_decoder_cmd *)ARG3; + POST_FIELD_WRITE(data->flags); + break; + } + case VKI_V4L2_ENUM_DV_TIMINGS: { + struct vki_v4l2_enum_dv_timings *data = (struct vki_v4l2_enum_dv_timings *)ARG3; + POST_FIELD_WRITE(data->timings); + break; + } + case VKI_V4L2_QUERY_DV_TIMINGS: { + struct vki_v4l2_dv_timings *data = (struct vki_v4l2_dv_timings *)ARG3; + POST_MEM_WRITE((Addr)data, sizeof(*data)); + break; + } + case VKI_V4L2_DV_TIMINGS_CAP: { + struct vki_v4l2_dv_timings_cap *data = (struct vki_v4l2_dv_timings_cap *)ARG3; + POST_MEM_WRITE((Addr)data, sizeof(*data)); + break; + } + case VKI_V4L2_ENUM_FREQ_BANDS: { + struct vki_v4l2_frequency_band *data = (struct vki_v4l2_frequency_band *)ARG3; + POST_FIELD_WRITE(data->capability); + POST_FIELD_WRITE(data->rangelow); + POST_FIELD_WRITE(data->rangehigh); + POST_FIELD_WRITE(data->modulation); + break; + } + case VKI_V4L2_DBG_G_CHIP_INFO: { + struct vki_v4l2_dbg_chip_info *data = (struct vki_v4l2_dbg_chip_info *)ARG3; + POST_FIELD_WRITE(data->name); + POST_FIELD_WRITE(data->flags); + break; + } + case VKI_V4L2_QUERY_EXT_CTRL: { + struct vki_v4l2_query_ext_ctrl *data = (struct vki_v4l2_query_ext_ctrl *)ARG3; + POST_MEM_WRITE((Addr)&data->type, + sizeof(*data) - sizeof(data->id) - sizeof(data->reserved)); + break; + } + + case VKI_V4L2_SUBDEV_S_FMT: + case VKI_V4L2_SUBDEV_S_FRAME_INTERVAL: + case VKI_V4L2_SUBDEV_S_CROP: + case VKI_V4L2_SUBDEV_S_SELECTION: + break; + + case VKI_V4L2_SUBDEV_G_FMT: { + struct vki_v4l2_subdev_format *data = (struct vki_v4l2_subdev_format *)ARG3; + POST_FIELD_WRITE(data->format); + break; + } + case VKI_V4L2_SUBDEV_G_FRAME_INTERVAL: { + struct vki_v4l2_subdev_frame_interval *data = (struct vki_v4l2_subdev_frame_interval *)ARG3; + POST_FIELD_WRITE(data->interval); + break; + } + case VKI_V4L2_SUBDEV_ENUM_MBUS_CODE: { + struct vki_v4l2_subdev_mbus_code_enum *data = (struct vki_v4l2_subdev_mbus_code_enum *)ARG3; + POST_FIELD_WRITE(data->code); + break; + } + case VKI_V4L2_SUBDEV_ENUM_FRAME_SIZE: { + struct vki_v4l2_subdev_frame_size_enum *data = (struct vki_v4l2_subdev_frame_size_enum *)ARG3; + POST_FIELD_WRITE(data->min_width); + POST_FIELD_WRITE(data->min_height); + POST_FIELD_WRITE(data->max_width); + POST_FIELD_WRITE(data->max_height); + break; + } + case VKI_V4L2_SUBDEV_ENUM_FRAME_INTERVAL: { + struct vki_v4l2_subdev_frame_interval_enum *data = (struct vki_v4l2_subdev_frame_interval_enum *)ARG3; + POST_FIELD_WRITE(data->interval); + break; + } + case VKI_V4L2_SUBDEV_G_CROP: { + struct vki_v4l2_subdev_crop *data = (struct vki_v4l2_subdev_crop *)ARG3; + POST_FIELD_WRITE(data->rect); + break; + } + case VKI_V4L2_SUBDEV_G_SELECTION: { + struct vki_v4l2_subdev_selection *data = (struct vki_v4l2_subdev_selection *)ARG3; + POST_FIELD_WRITE(data->r); + break; + } + case VKI_MEDIA_IOC_DEVICE_INFO: { + struct vki_media_device_info *data = (struct vki_media_device_info *)ARG3; + POST_MEM_WRITE((Addr)data, sizeof(*data) - sizeof(data->reserved)); + break; + } + case VKI_MEDIA_IOC_ENUM_ENTITIES: { + struct vki_media_entity_desc *data = (struct vki_media_entity_desc *)ARG3; + POST_MEM_WRITE((Addr)data->name, sizeof(*data) - sizeof(data->id)); + break; + } + case VKI_MEDIA_IOC_ENUM_LINKS: + /* + * This ioctl does write to the provided pointers, but it's not + * possible to deduce the size of the array those pointers point to. + */ + break; + case VKI_MEDIA_IOC_SETUP_LINK: + break; + default: /* EVIOC* are variable length and return size written on success */ switch (ARG2 & ~(_VKI_IOC_SIZEMASK << _VKI_IOC_SIZESHIFT)) { diff --git a/include/vki/vki-linux.h b/include/vki/vki-linux.h index bab688e94e..027ce7e232 100644 --- a/include/vki/vki-linux.h +++ b/include/vki/vki-linux.h @@ -3572,6 +3572,936 @@ struct vki_getinfo_fid2path { #define VKI_OBD_IOC_FID2PATH \ _VKI_IOWR ('f', 150, VKI_OBD_IOC_DATA_TYPE) +struct vki_v4l2_rect { + __vki_s32 left; + __vki_s32 top; + __vki_u32 width; + __vki_u32 height; +}; + +struct vki_v4l2_fract { + __vki_u32 numerator; + __vki_u32 denominator; +}; + +struct vki_v4l2_capability { + __vki_u8 driver[16]; + __vki_u8 card[32]; + __vki_u8 bus_info[32]; + __vki_u32 version; + __vki_u32 capabilities; + __vki_u32 device_caps; + __vki_u32 reserved[3]; +}; + +struct vki_v4l2_pix_format { + __vki_u32 width; + __vki_u32 height; + __vki_u32 pixelformat; + __vki_u32 field; /* enum vki_v4l2_field */ + __vki_u32 bytesperline; /* for padding, zero if unused */ + __vki_u32 sizeimage; + __vki_u32 colorspace; /* enum vki_v4l2_colorspace */ + __vki_u32 priv; /* private data, depends on pixelformat */ + __vki_u32 flags; /* format flags (VKI_V4L2_PIX_FMT_FLAG_*) */ +}; + +struct vki_v4l2_fmtdesc { + __vki_u32 index; /* Format number */ + __vki_u32 type; /* enum vki_v4l2_buf_type */ + __vki_u32 flags; + __vki_u8 description[32]; /* Description string */ + __vki_u32 pixelformat; /* Format fourcc */ + __vki_u32 reserved[4]; +}; + +struct vki_v4l2_frmsize_discrete { + __vki_u32 width; /* Frame width [pixel] */ + __vki_u32 height; /* Frame height [pixel] */ +}; + +struct vki_v4l2_frmsize_stepwise { + __vki_u32 min_width; /* Minimum frame width [pixel] */ + __vki_u32 max_width; /* Maximum frame width [pixel] */ + __vki_u32 step_width; /* Frame width step size [pixel] */ + __vki_u32 min_height; /* Minimum frame height [pixel] */ + __vki_u32 max_height; /* Maximum frame height [pixel] */ + __vki_u32 step_height; /* Frame height step size [pixel] */ +}; + +struct vki_v4l2_frmsizeenum { + __vki_u32 index; /* Frame size number */ + __vki_u32 pixel_format; /* Pixel format */ + __vki_u32 type; /* Frame size type the device supports. */ + + union { /* Frame size */ + struct vki_v4l2_frmsize_discrete discrete; + struct vki_v4l2_frmsize_stepwise stepwise; + }; + + __vki_u32 reserved[2]; /* Reserved space for future use */ +}; + +struct vki_v4l2_frmival_stepwise { + struct vki_v4l2_fract min; + struct vki_v4l2_fract max; + struct vki_v4l2_fract step; +}; + +struct vki_v4l2_frmivalenum { + __vki_u32 index; + __vki_u32 pixel_format; + __vki_u32 width; + __vki_u32 height; + __vki_u32 type; + + union { + struct vki_v4l2_fract discrete; + struct vki_v4l2_frmival_stepwise stepwise; + }; + + __vki_u32 reserved[2]; +}; + +struct vki_v4l2_timecode { + __vki_u32 type; + __vki_u32 flags; + __vki_u8 frames; + __vki_u8 seconds; + __vki_u8 minutes; + __vki_u8 hours; + __vki_u8 userbits[4]; +}; + +struct vki_v4l2_jpegcompression { + int quality; + int APPn; + int APP_len; + char APP_data[60]; + int COM_len; + char COM_data[60]; + __vki_u32 jpeg_markers; +}; + +struct vki_v4l2_requestbuffers { + __vki_u32 count; + __vki_u32 type; + __vki_u32 memory; + __vki_u32 reserved[2]; +}; + +struct vki_v4l2_plane { + __vki_u32 bytesused; + __vki_u32 length; + union { + __vki_u32 mem_offset; + unsigned long userptr; + __vki_s32 fd; + } m; + __vki_u32 data_offset; + __vki_u32 reserved[11]; +}; + +#define VKI_V4L2_MEMORY_MMAP 1 +#define VKI_V4L2_MEMORY_DMABUF 4 +#define VKI_V4L2_BUF_FLAG_TIMESTAMP_MASK 0x0000e000 +#define VKI_V4L2_BUF_FLAG_TIMESTAMP_COPY 0x00004000 +struct vki_v4l2_buffer { + __vki_u32 index; + __vki_u32 type; + __vki_u32 bytesused; + __vki_u32 flags; + __vki_u32 field; + struct vki_timeval timestamp; + struct vki_v4l2_timecode timecode; + __vki_u32 sequence; + + /* memory location */ + __vki_u32 memory; + union { + __vki_u32 offset; + unsigned long userptr; + struct vki_v4l2_plane *planes; + __vki_s32 fd; + } m; + __vki_u32 length; + __vki_u32 reserved2; + __vki_u32 reserved; +}; + +struct vki_v4l2_exportbuffer { + __vki_u32 type; /* enum vki_v4l2_buf_type */ + __vki_u32 index; + __vki_u32 plane; + __vki_u32 flags; + __vki_s32 fd; + __vki_u32 reserved[11]; +}; + +struct vki_v4l2_framebuffer { + __vki_u32 capability; + __vki_u32 flags; + void *base; + struct { + __vki_u32 width; + __vki_u32 height; + __vki_u32 pixelformat; + __vki_u32 field; /* enum vki_v4l2_field */ + __vki_u32 bytesperline; /* for padding, zero if unused */ + __vki_u32 sizeimage; + __vki_u32 colorspace; /* enum vki_v4l2_colorspace */ + __vki_u32 priv; /* reserved field, set to 0 */ + } fmt; +}; + +struct vki_v4l2_clip { + struct vki_v4l2_rect c; + struct vki_v4l2_clip __user *next; +}; + +struct vki_v4l2_window { + struct vki_v4l2_rect w; + __vki_u32 field; /* enum vki_v4l2_field */ + __vki_u32 chromakey; + struct vki_v4l2_clip __user *clips; + __vki_u32 clipcount; + void __user *bitmap; + __vki_u8 global_alpha; +}; + +struct vki_v4l2_captureparm { + __vki_u32 capability; /* Supported modes */ + __vki_u32 capturemode; /* Current mode */ + struct vki_v4l2_fract timeperframe; /* Time per frame in seconds */ + __vki_u32 extendedmode; /* Driver-specific extensions */ + __vki_u32 readbuffers; /* # of buffers for read */ + __vki_u32 reserved[4]; +}; + +struct vki_v4l2_outputparm { + __vki_u32 capability; /* Supported modes */ + __vki_u32 outputmode; /* Current mode */ + struct vki_v4l2_fract timeperframe; /* Time per frame in seconds */ + __vki_u32 extendedmode; /* Driver-specific extensions */ + __vki_u32 writebuffers; /* # of buffers for write */ + __vki_u32 reserved[4]; +}; + +struct vki_v4l2_cropcap { + __vki_u32 type; /* enum vki_v4l2_buf_type */ + struct vki_v4l2_rect bounds; + struct vki_v4l2_rect defrect; + struct vki_v4l2_fract pixelaspect; +}; + +struct vki_v4l2_crop { + __vki_u32 type; /* enum vki_v4l2_buf_type */ + struct vki_v4l2_rect c; +}; + +struct vki_v4l2_selection { + __vki_u32 type; + __vki_u32 target; + __vki_u32 flags; + struct vki_v4l2_rect r; + __vki_u32 reserved[9]; +}; + +typedef __vki_u64 vki_v4l2_std_id; + +struct vki_v4l2_standard { + __vki_u32 index; + vki_v4l2_std_id id; + __vki_u8 name[24]; + struct vki_v4l2_fract frameperiod; /* Frames, not fields */ + __vki_u32 framelines; + __vki_u32 reserved[4]; +}; + +struct vki_v4l2_bt_timings { + __vki_u32 width; + __vki_u32 height; + __vki_u32 interlaced; + __vki_u32 polarities; + __vki_u64 pixelclock; + __vki_u32 hfrontporch; + __vki_u32 hsync; + __vki_u32 hbackporch; + __vki_u32 vfrontporch; + __vki_u32 vsync; + __vki_u32 vbackporch; + __vki_u32 il_vfrontporch; + __vki_u32 il_vsync; + __vki_u32 il_vbackporch; + __vki_u32 standards; + __vki_u32 flags; + __vki_u32 reserved[14]; +} __attribute__ ((packed)); + +struct vki_v4l2_dv_timings { + __vki_u32 type; + union { + struct vki_v4l2_bt_timings bt; + __vki_u32 reserved[32]; + }; +} __attribute__ ((packed)); + +struct vki_v4l2_enum_dv_timings { + __vki_u32 index; + __vki_u32 pad; + __vki_u32 reserved[2]; + struct vki_v4l2_dv_timings timings; +}; + +struct vki_v4l2_bt_timings_cap { + __vki_u32 min_width; + __vki_u32 max_width; + __vki_u32 min_height; + __vki_u32 max_height; + __vki_u64 min_pixelclock; + __vki_u64 max_pixelclock; + __vki_u32 standards; + __vki_u32 capabilities; + __vki_u32 reserved[16]; +} __attribute__ ((packed)); + +struct vki_v4l2_dv_timings_cap { + __vki_u32 type; + __vki_u32 pad; + __vki_u32 reserved[2]; + union { + struct vki_v4l2_bt_timings_cap bt; + __vki_u32 raw_data[32]; + }; +}; + +struct vki_v4l2_input { + __vki_u32 index; /* Which input */ + __vki_u8 name[32]; /* Label */ + __vki_u32 type; /* Type of input */ + __vki_u32 audioset; /* Associated audios (bitfield) */ + __vki_u32 tuner; /* enum vki_v4l2_tuner_type */ + vki_v4l2_std_id std; + __vki_u32 status; + __vki_u32 capabilities; + __vki_u32 reserved[3]; +}; + +struct vki_v4l2_output { + __vki_u32 index; /* Which output */ + __vki_u8 name[32]; /* Label */ + __vki_u32 type; /* Type of output */ + __vki_u32 audioset; /* Associated audios (bitfield) */ + __vki_u32 modulator; /* Associated modulator */ + vki_v4l2_std_id std; + __vki_u32 capabilities; + __vki_u32 reserved[3]; +}; + +struct vki_v4l2_control { + __vki_u32 id; + __vki_s32 value; +}; + +struct vki_v4l2_ext_control { + __vki_u32 id; + __vki_u32 size; + __vki_u32 reserved2[1]; + union { + __vki_s32 value; + __vki_s64 value64; + char *string; + __vki_u8 *p_u8; + __vki_u16 *p_u16; + __vki_u32 *p_u32; + void *ptr; + }; +} __attribute__ ((packed)); + +struct vki_v4l2_ext_controls { + __vki_u32 ctrl_class; + __vki_u32 count; + __vki_u32 error_idx; + __vki_u32 reserved[2]; + struct vki_v4l2_ext_control *controls; +}; + +struct vki_v4l2_queryctrl { + __vki_u32 id; + __vki_u32 type; /* enum vki_v4l2_ctrl_type */ + __vki_u8 name[32]; /* Whatever */ + __vki_s32 minimum; /* Note signedness */ + __vki_s32 maximum; + __vki_s32 step; + __vki_s32 default_value; + __vki_u32 flags; + __vki_u32 reserved[2]; +}; + +#define VKI_V4L2_CTRL_MAX_DIMS (4) +struct vki_v4l2_query_ext_ctrl { + __vki_u32 id; + __vki_u32 type; + char name[32]; + __vki_s64 minimum; + __vki_s64 maximum; + __vki_u64 step; + __vki_s64 default_value; + __vki_u32 flags; + __vki_u32 elem_size; + __vki_u32 elems; + __vki_u32 nr_of_dims; + __vki_u32 dims[VKI_V4L2_CTRL_MAX_DIMS]; + __vki_u32 reserved[32]; +}; + +struct vki_v4l2_querymenu { + __vki_u32 id; + __vki_u32 index; + union { + __vki_u8 name[32]; /* Whatever */ + __vki_s64 value; + }; + __vki_u32 reserved; +} __attribute__ ((packed)); + +struct vki_v4l2_tuner { + __vki_u32 index; + __vki_u8 name[32]; + __vki_u32 type; /* enum vki_v4l2_tuner_type */ + __vki_u32 capability; + __vki_u32 rangelow; + __vki_u32 rangehigh; + __vki_u32 rxsubchans; + __vki_u32 audmode; + __vki_s32 signal; + __vki_s32 afc; + __vki_u32 reserved[4]; +}; + +struct vki_v4l2_modulator { + __vki_u32 index; + __vki_u8 name[32]; + __vki_u32 capability; + __vki_u32 rangelow; + __vki_u32 rangehigh; + __vki_u32 txsubchans; + __vki_u32 reserved[4]; +}; + +struct vki_v4l2_frequency { + __vki_u32 tuner; + __vki_u32 type; /* enum vki_v4l2_tuner_type */ + __vki_u32 frequency; + __vki_u32 reserved[8]; +}; + +struct vki_v4l2_frequency_band { + __vki_u32 tuner; + __vki_u32 type; /* enum vki_v4l2_tuner_type */ + __vki_u32 index; + __vki_u32 capability; + __vki_u32 rangelow; + __vki_u32 rangehigh; + __vki_u32 modulation; + __vki_u32 reserved[9]; +}; + +struct vki_v4l2_hw_freq_seek { + __vki_u32 tuner; + __vki_u32 type; /* enum vki_v4l2_tuner_type */ + __vki_u32 seek_upward; + __vki_u32 wrap_around; + __vki_u32 spacing; + __vki_u32 rangelow; + __vki_u32 rangehigh; + __vki_u32 reserved[5]; +}; + +struct vki_v4l2_audio { + __vki_u32 index; + __vki_u8 name[32]; + __vki_u32 capability; + __vki_u32 mode; + __vki_u32 reserved[2]; +}; + +struct vki_v4l2_audioout { + __vki_u32 index; + __vki_u8 name[32]; + __vki_u32 capability; + __vki_u32 mode; + __vki_u32 reserved[2]; +}; + +struct vki_v4l2_enc_idx_entry { + __vki_u64 offset; + __vki_u64 pts; + __vki_u32 length; + __vki_u32 flags; + __vki_u32 reserved[2]; +}; + +#define VKI_V4L2_ENC_IDX_ENTRIES (64) +struct vki_v4l2_enc_idx { + __vki_u32 entries; + __vki_u32 entries_cap; + __vki_u32 reserved[4]; + struct vki_v4l2_enc_idx_entry entry[VKI_V4L2_ENC_IDX_ENTRIES]; +}; + +struct vki_v4l2_encoder_cmd { + __vki_u32 cmd; + __vki_u32 flags; + union { + struct { + __vki_u32 data[8]; + } raw; + }; +}; + +struct vki_v4l2_decoder_cmd { + __vki_u32 cmd; + __vki_u32 flags; + union { + struct { + __vki_u64 pts; + } stop; + + struct { + __vki_s32 speed; + __vki_u32 format; + } start; + + struct { + __vki_u32 data[16]; + } raw; + }; +}; + +struct vki_v4l2_vbi_format { + __vki_u32 sampling_rate; /* in 1 Hz */ + __vki_u32 offset; + __vki_u32 samples_per_line; + __vki_u32 sample_format; /* VKI_V4L2_PIX_FMT_* */ + __vki_s32 start[2]; + __vki_u32 count[2]; + __vki_u32 flags; /* VKI_V4L2_VBI_* */ + __vki_u32 reserved[2]; /* must be zero */ +}; + +struct vki_v4l2_sliced_vbi_format { + __vki_u16 service_set; + __vki_u16 service_lines[2][24]; + __vki_u32 io_size; + __vki_u32 reserved[2]; /* must be zero */ +}; + +struct vki_v4l2_sliced_vbi_cap { + __vki_u16 service_set; + __vki_u16 service_lines[2][24]; + __vki_u32 type; /* enum vki_v4l2_buf_type */ + __vki_u32 reserved[3]; /* must be 0 */ +}; + +struct vki_v4l2_sliced_vbi_data { + __vki_u32 id; + __vki_u32 field; /* 0: first field, 1: second field */ + __vki_u32 line; /* 1-23 */ + __vki_u32 reserved; /* must be 0 */ + __vki_u8 data[48]; +}; + +struct vki_v4l2_plane_pix_format { + __vki_u32 sizeimage; + __vki_u16 bytesperline; + __vki_u16 reserved[7]; +} __attribute__ ((packed)); + +#define VKI_VIDEO_MAX_PLANES 8 + +struct vki_v4l2_pix_format_mplane { + __vki_u32 width; + __vki_u32 height; + __vki_u32 pixelformat; + __vki_u32 field; + __vki_u32 colorspace; + + struct vki_v4l2_plane_pix_format plane_fmt[VKI_VIDEO_MAX_PLANES]; + __vki_u8 num_planes; + __vki_u8 flags; + __vki_u8 reserved[10]; +} __attribute__ ((packed)); + +struct vki_v4l2_sdr_format { + __vki_u32 pixelformat; + __vki_u32 buffersize; + __vki_u8 reserved[24]; +} __attribute__ ((packed)); + +enum vki_v4l2_buf_type { + VKI_V4L2_BUF_TYPE_VIDEO_CAPTURE = 1, + VKI_V4L2_BUF_TYPE_VIDEO_OUTPUT = 2, + VKI_V4L2_BUF_TYPE_VIDEO_OVERLAY = 3, + VKI_V4L2_BUF_TYPE_VBI_CAPTURE = 4, + VKI_V4L2_BUF_TYPE_VBI_OUTPUT = 5, + VKI_V4L2_BUF_TYPE_SLICED_VBI_CAPTURE = 6, + VKI_V4L2_BUF_TYPE_SLICED_VBI_OUTPUT = 7, + VKI_V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY = 8, + VKI_V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE = 9, + VKI_V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE = 10, + VKI_V4L2_BUF_TYPE_SDR_CAPTURE = 11, +}; + +struct vki_v4l2_format { + __vki_u32 type; + union { + struct vki_v4l2_pix_format pix; + struct vki_v4l2_pix_format_mplane pix_mp; + struct vki_v4l2_window win; + struct vki_v4l2_vbi_format vbi; + struct vki_v4l2_sliced_vbi_format sliced; + struct vki_v4l2_sdr_format sdr; + __vki_u8 raw_data[200]; + } fmt; +}; + +struct vki_v4l2_streamparm { + __vki_u32 type; + union { + struct vki_v4l2_captureparm capture; + struct vki_v4l2_outputparm output; + __vki_u8 raw_data[200]; /* user-defined */ + } parm; +}; + +struct vki_v4l2_event_vsync { + __vki_u8 field; +} __attribute__ ((packed)); + +struct vki_v4l2_event_ctrl { + __vki_u32 changes; + __vki_u32 type; + union { + __vki_s32 value; + __vki_s64 value64; + }; + __vki_u32 flags; + __vki_s32 minimum; + __vki_s32 maximum; + __vki_s32 step; + __vki_s32 default_value; +}; + +struct vki_v4l2_event_frame_sync { + __vki_u32 frame_sequence; +}; + +struct vki_v4l2_event_src_change { + __vki_u32 changes; +}; + +struct vki_v4l2_event_motion_det { + __vki_u32 flags; + __vki_u32 frame_sequence; + __vki_u32 region_mask; +}; + +struct vki_v4l2_event { + __vki_u32 type; + union { + struct vki_v4l2_event_vsync vsync; + struct vki_v4l2_event_ctrl ctrl; + struct vki_v4l2_event_frame_sync frame_sync; + struct vki_v4l2_event_src_change src_change; + struct vki_v4l2_event_motion_det motion_det; + __vki_u8 data[64]; + } u; + __vki_u32 pending; + __vki_u32 sequence; + struct vki_timespec timestamp; + __vki_u32 id; + __vki_u32 reserved[8]; +}; + +struct vki_v4l2_event_subscription { + __vki_u32 type; + __vki_u32 id; + __vki_u32 flags; + __vki_u32 reserved[5]; +}; + +struct vki_v4l2_dbg_match { + __vki_u32 type; /* Match type */ + union { /* Match this chip, meaning determined by type */ + __vki_u32 addr; + char name[32]; + }; +} __attribute__ ((packed)); + +struct vki_v4l2_dbg_register { + struct vki_v4l2_dbg_match match; + __vki_u32 size; /* register size in bytes */ + __vki_u64 reg; + __vki_u64 val; +} __attribute__ ((packed)); + +struct vki_v4l2_dbg_chip_info { + struct vki_v4l2_dbg_match match; + char name[32]; + __vki_u32 flags; + __vki_u32 reserved[32]; +} __attribute__ ((packed)); + +struct vki_v4l2_create_buffers { + __vki_u32 index; + __vki_u32 count; + __vki_u32 memory; + struct vki_v4l2_format format; + __vki_u32 reserved[8]; +}; + +struct vki_v4l2_edid { + __vki_u32 pad; + __vki_u32 start_block; + __vki_u32 blocks; + __vki_u32 reserved[5]; + __vki_u8 *edid; +}; + +#define VKI_V4L2_QUERYCAP _VKI_IOR('V', 0, struct vki_v4l2_capability) +#define VKI_V4L2_ENUM_FMT _VKI_IOWR('V', 2, struct vki_v4l2_fmtdesc) +#define VKI_V4L2_G_FMT _VKI_IOWR('V', 4, struct vki_v4l2_format) +#define VKI_V4L2_S_FMT _VKI_IOWR('V', 5, struct vki_v4l2_format) +#define VKI_V4L2_REQBUFS _VKI_IOWR('V', 8, struct vki_v4l2_requestbuffers) +#define VKI_V4L2_QUERYBUF _VKI_IOWR('V', 9, struct vki_v4l2_buffer) +#define VKI_V4L2_G_FBUF _VKI_IOR('V', 10, struct vki_v4l2_framebuffer) +#define VKI_V4L2_S_FBUF _VKI_IOW('V', 11, struct vki_v4l2_framebuffer) +#define VKI_V4L2_OVERLAY _VKI_IOW('V', 14, int) +#define VKI_V4L2_QBUF _VKI_IOWR('V', 15, struct vki_v4l2_buffer) +#define VKI_V4L2_EXPBUF _VKI_IOWR('V', 16, struct vki_v4l2_exportbuffer) +#define VKI_V4L2_DQBUF _VKI_IOWR('V', 17, struct vki_v4l2_buffer) +#define VKI_V4L2_STREAMON _VKI_IOW('V', 18, int) +#define VKI_V4L2_STREAMOFF _VKI_IOW('V', 19, int) +#define VKI_V4L2_G_PARM _VKI_IOWR('V', 21, struct vki_v4l2_streamparm) +#define VKI_V4L2_S_PARM _VKI_IOWR('V', 22, struct vki_v4l2_streamparm) +#define VKI_V4L2_G_STD _VKI_IOR('V', 23, vki_v4l2_std_id) +#define VKI_V4L2_S_STD _VKI_IOW('V', 24, vki_v4l2_std_id) +#define VKI_V4L2_ENUMSTD _VKI_IOWR('V', 25, struct vki_v4l2_standard) +#define VKI_V4L2_ENUMINPUT _VKI_IOWR('V', 26, struct vki_v4l2_input) +#define VKI_V4L2_G_CTRL _VKI_IOWR('V', 27, struct vki_v4l2_control) +#define VKI_V4L2_S_CTRL _VKI_IOWR('V', 28, struct vki_v4l2_control) +#define VKI_V4L2_G_TUNER _VKI_IOWR('V', 29, struct vki_v4l2_tuner) +#define VKI_V4L2_S_TUNER _VKI_IOW('V', 30, struct vki_v4l2_tuner) +#define VKI_V4L2_G_AUDIO _VKI_IOR('V', 33, struct vki_v4l2_audio) +#define VKI_V4L2_S_AUDIO _VKI_IOW('V', 34, struct vki_v4l2_audio) +#define VKI_V4L2_QUERYCTRL _VKI_IOWR('V', 36, struct vki_v4l2_queryctrl) +#define VKI_V4L2_QUERYMENU _VKI_IOWR('V', 37, struct vki_v4l2_querymenu) +#define VKI_V4L2_G_INPUT _VKI_IOR('V', 38, int) +#define VKI_V4L2_S_INPUT _VKI_IOWR('V', 39, int) +#define VKI_V4L2_G_EDID _VKI_IOWR('V', 40, struct vki_v4l2_edid) +#define VKI_V4L2_S_EDID _VKI_IOWR('V', 41, struct vki_v4l2_edid) +#define VKI_V4L2_G_OUTPUT _VKI_IOR('V', 46, int) +#define VKI_V4L2_S_OUTPUT _VKI_IOWR('V', 47, int) +#define VKI_V4L2_ENUMOUTPUT _VKI_IOWR('V', 48, struct vki_v4l2_output) +#define VKI_V4L2_G_AUDOUT _VKI_IOR('V', 49, struct vki_v4l2_audioout) +#define VKI_V4L2_S_AUDOUT _VKI_IOW('V', 50, struct vki_v4l2_audioout) +#define VKI_V4L2_G_MODULATOR _VKI_IOWR('V', 54, struct vki_v4l2_modulator) +#define VKI_V4L2_S_MODULATOR _VKI_IOW('V', 55, struct vki_v4l2_modulator) +#define VKI_V4L2_G_FREQUENCY _VKI_IOWR('V', 56, struct vki_v4l2_frequency) +#define VKI_V4L2_S_FREQUENCY _VKI_IOW('V', 57, struct vki_v4l2_frequency) +#define VKI_V4L2_CROPCAP _VKI_IOWR('V', 58, struct vki_v4l2_cropcap) +#define VKI_V4L2_G_CROP _VKI_IOWR('V', 59, struct vki_v4l2_crop) +#define VKI_V4L2_S_CROP _VKI_IOW('V', 60, struct vki_v4l2_crop) +#define VKI_V4L2_G_JPEGCOMP _VKI_IOR('V', 61, struct vki_v4l2_jpegcompression) +#define VKI_V4L2_S_JPEGCOMP _VKI_IOW('V', 62, struct vki_v4l2_jpegcompression) +#define VKI_V4L2_QUERYSTD _VKI_IOR('V', 63, vki_v4l2_std_id) +#define VKI_V4L2_TRY_FMT _VKI_IOWR('V', 64, struct vki_v4l2_format) +#define VKI_V4L2_ENUMAUDIO _VKI_IOWR('V', 65, struct vki_v4l2_audio) +#define VKI_V4L2_ENUMAUDOUT _VKI_IOWR('V', 66, struct vki_v4l2_audioout) +#define VKI_V4L2_G_PRIORITY _VKI_IOR('V', 67, __vki_u32) +#define VKI_V4L2_S_PRIORITY _VKI_IOW('V', 68, __vki_u32) +#define VKI_V4L2_G_SLICED_VBI_CAP _VKI_IOWR('V', 69, struct vki_v4l2_sliced_vbi_cap) +#define VKI_V4L2_LOG_STATUS _VKI_IO('V', 70) +#define VKI_V4L2_G_EXT_CTRLS _VKI_IOWR('V', 71, struct vki_v4l2_ext_controls) +#define VKI_V4L2_S_EXT_CTRLS _VKI_IOWR('V', 72, struct vki_v4l2_ext_controls) +#define VKI_V4L2_TRY_EXT_CTRLS _VKI_IOWR('V', 73, struct vki_v4l2_ext_controls) +#define VKI_V4L2_ENUM_FRAMESIZES _VKI_IOWR('V', 74, struct vki_v4l2_frmsizeenum) +#define VKI_V4L2_ENUM_FRAMEINTERVALS _VKI_IOWR('V', 75, struct vki_v4l2_frmivalenum) +#define VKI_V4L2_G_ENC_INDEX _VKI_IOR('V', 76, struct vki_v4l2_enc_idx) +#define VKI_V4L2_ENCODER_CMD _VKI_IOWR('V', 77, struct vki_v4l2_encoder_cmd) +#define VKI_V4L2_TRY_ENCODER_CMD _VKI_IOWR('V', 78, struct vki_v4l2_encoder_cmd) +#define VKI_V4L2_DBG_S_REGISTER _VKI_IOW('V', 79, struct vki_v4l2_dbg_register) +#define VKI_V4L2_DBG_G_REGISTER _VKI_IOWR('V', 80, struct vki_v4l2_dbg_register) +#define VKI_V4L2_S_HW_FREQ_SEEK _VKI_IOW('V', 82, struct vki_v4l2_hw_freq_seek) +#define VKI_V4L2_S_DV_TIMINGS _VKI_IOWR('V', 87, struct vki_v4l2_dv_timings) +#define VKI_V4L2_G_DV_TIMINGS _VKI_IOWR('V', 88, struct vki_v4l2_dv_timings) +#define VKI_V4L2_DQEVENT _VKI_IOR('V', 89, struct vki_v4l2_event) +#define VKI_V4L2_SUBSCRIBE_EVENT _VKI_IOW('V', 90, struct vki_v4l2_event_subscription) +#define VKI_V4L2_UNSUBSCRIBE_EVENT _VKI_IOW('V', 91, struct vki_v4l2_event_subscription) +#define VKI_V4L2_CREATE_BUFS _VKI_IOWR('V', 92, struct vki_v4l2_create_buffers) +#define VKI_V4L2_PREPARE_BUF _VKI_IOWR('V', 93, struct vki_v4l2_buffer) +#define VKI_V4L2_G_SELECTION _VKI_IOWR('V', 94, struct vki_v4l2_selection) +#define VKI_V4L2_S_SELECTION _VKI_IOWR('V', 95, struct vki_v4l2_selection) +#define VKI_V4L2_DECODER_CMD _VKI_IOWR('V', 96, struct vki_v4l2_decoder_cmd) +#define VKI_V4L2_TRY_DECODER_CMD _VKI_IOWR('V', 97, struct vki_v4l2_decoder_cmd) +#define VKI_V4L2_ENUM_DV_TIMINGS _VKI_IOWR('V', 98, struct vki_v4l2_enum_dv_timings) +#define VKI_V4L2_QUERY_DV_TIMINGS _VKI_IOR('V', 99, struct vki_v4l2_dv_timings) +#define VKI_V4L2_DV_TIMINGS_CAP _VKI_IOWR('V', 100, struct vki_v4l2_dv_timings_cap) +#define VKI_V4L2_ENUM_FREQ_BANDS _VKI_IOWR('V', 101, struct vki_v4l2_frequency_band) +#define VKI_V4L2_DBG_G_CHIP_INFO _VKI_IOWR('V', 102, struct vki_v4l2_dbg_chip_info) +#define VKI_V4L2_QUERY_EXT_CTRL _VKI_IOWR('V', 103, struct vki_v4l2_query_ext_ctrl) + +struct vki_v4l2_mbus_framefmt { + __vki_u32 width; + __vki_u32 height; + __vki_u32 code; + __vki_u32 field; + __vki_u32 colorspace; + __vki_u32 reserved[7]; +}; + +struct vki_v4l2_subdev_format { + __vki_u32 which; + __vki_u32 pad; + struct vki_v4l2_mbus_framefmt format; + __vki_u32 reserved[8]; +}; + +struct vki_v4l2_subdev_crop { + __vki_u32 which; + __vki_u32 pad; + struct vki_v4l2_rect rect; + __vki_u32 reserved[8]; +}; + +struct vki_v4l2_subdev_mbus_code_enum { + __vki_u32 pad; + __vki_u32 index; + __vki_u32 code; + __vki_u32 reserved[9]; +}; + +struct vki_v4l2_subdev_frame_size_enum { + __vki_u32 index; + __vki_u32 pad; + __vki_u32 code; + __vki_u32 min_width; + __vki_u32 max_width; + __vki_u32 min_height; + __vki_u32 max_height; + __vki_u32 reserved[9]; +}; + +struct vki_v4l2_subdev_frame_interval { + __vki_u32 pad; + struct vki_v4l2_fract interval; + __vki_u32 reserved[9]; +}; + +struct vki_v4l2_subdev_frame_interval_enum { + __vki_u32 index; + __vki_u32 pad; + __vki_u32 code; + __vki_u32 width; + __vki_u32 height; + struct vki_v4l2_fract interval; + __vki_u32 reserved[9]; +}; + +struct vki_v4l2_subdev_selection { + __vki_u32 which; + __vki_u32 pad; + __vki_u32 target; + __vki_u32 flags; + struct vki_v4l2_rect r; + __vki_u32 reserved[8]; +}; + +#define VKI_V4L2_SUBDEV_G_FMT _VKI_IOWR('V', 4, struct vki_v4l2_subdev_format) +#define VKI_V4L2_SUBDEV_S_FMT _VKI_IOWR('V', 5, struct vki_v4l2_subdev_format) +#define VKI_V4L2_SUBDEV_G_FRAME_INTERVAL _VKI_IOWR('V', 21, struct vki_v4l2_subdev_frame_interval) +#define VKI_V4L2_SUBDEV_S_FRAME_INTERVAL _VKI_IOWR('V', 22, struct vki_v4l2_subdev_frame_interval) +#define VKI_V4L2_SUBDEV_ENUM_MBUS_CODE _VKI_IOWR('V', 2, struct vki_v4l2_subdev_mbus_code_enum) +#define VKI_V4L2_SUBDEV_ENUM_FRAME_SIZE _VKI_IOWR('V', 74, struct vki_v4l2_subdev_frame_size_enum) +#define VKI_V4L2_SUBDEV_ENUM_FRAME_INTERVAL _VKI_IOWR('V', 75, struct vki_v4l2_subdev_frame_interval_enum) +#define VKI_V4L2_SUBDEV_G_CROP _VKI_IOWR('V', 59, struct vki_v4l2_subdev_crop) +#define VKI_V4L2_SUBDEV_S_CROP _VKI_IOWR('V', 60, struct vki_v4l2_subdev_crop) +#define VKI_V4L2_SUBDEV_G_SELECTION _VKI_IOWR('V', 61, struct vki_v4l2_subdev_selection) +#define VKI_V4L2_SUBDEV_S_SELECTION _VKI_IOWR('V', 62, struct vki_v4l2_subdev_selection) + +struct vki_media_device_info { + char driver[16]; + char model[32]; + char serial[40]; + char bus_info[32]; + __vki_u32 media_version; + __vki_u32 hw_revision; + __vki_u32 driver_version; + __vki_u32 reserved[31]; +}; + +struct vki_media_entity_desc { + __vki_u32 id; + char name[32]; + __vki_u32 type; + __vki_u32 revision; + __vki_u32 flags; + __vki_u32 group_id; + __vki_u16 pads; + __vki_u16 links; + + __vki_u32 reserved[4]; + + union { + /* Node specifications */ + struct { + __vki_u32 major; + __vki_u32 minor; + } v4l; + struct { + __vki_u32 major; + __vki_u32 minor; + } fb; + struct { + __vki_u32 card; + __vki_u32 device; + __vki_u32 subdevice; + } alsa; + int dvb; + + /* Sub-device specifications */ + /* Nothing needed yet */ + __vki_u8 raw[184]; + }; +}; + +struct vki_media_pad_desc { + __vki_u32 entity; /* entity ID */ + __vki_u16 index; /* pad index */ + __vki_u32 flags; /* pad flags */ + __vki_u32 reserved[2]; +}; + +struct vki_media_link_desc { + struct vki_media_pad_desc source; + struct vki_media_pad_desc sink; + __vki_u32 flags; + __vki_u32 reserved[2]; +}; + +struct vki_media_links_enum { + __vki_u32 entity; + struct vki_media_pad_desc __user *pads; + struct vki_media_link_desc __user *links; + __vki_u32 reserved[4]; +}; + +#define VKI_MEDIA_IOC_DEVICE_INFO _VKI_IOWR('|', 0x00, struct vki_media_device_info) +#define VKI_MEDIA_IOC_ENUM_ENTITIES _VKI_IOWR('|', 0x01, struct vki_media_entity_desc) +#define VKI_MEDIA_IOC_ENUM_LINKS _VKI_IOWR('|', 0x02, struct vki_media_links_enum) +#define VKI_MEDIA_IOC_SETUP_LINK _VKI_IOWR('|', 0x03, struct vki_media_link_desc) + #endif // __VKI_LINUX_H /*--------------------------------------------------------------------*/ -- 2.47.2