/* 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);
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)) {
}
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)) {
#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
/*--------------------------------------------------------------------*/
projects / thirdparty / valgrind.git / commitdiff
