Merge pull request #4887 from Sonicadvance1/finish_v4l2

IoctlEmulation: Finish v4l2 implementation

Source/Tools/LinuxEmulation/LinuxSyscalls/x32/Ioctl/v4l2.h

@@ -8,6 +8,27 @@
 #define CPYT(x) val.x = x
 #define CPYF(x) x = val.x
 
+extern "C" {
+// Upstream definitions that changed over time.
+struct upstream_v4l2_create_buffers {
+  uint32_t index;
+  uint32_t count;
+  uint32_t memory;
+  struct v4l2_format format;
+  uint32_t capabilities;
+  uint32_t flags;
+  uint32_t max_num_buffers;
+  uint32_t reserved[5];
+};
+
+struct upstream_v4l2_remove_buffers {
+  uint32_t index;
+  uint32_t count;
+  uint32_t type;
+  uint32_t reserved[13];
+};
+}
+
 namespace FEX::HLE::x32 {
 namespace V4l2 {
 
@@ -72,6 +93,365 @@ namespace V4l2 {
     }
   };
 
+  struct FEX_ANNOTATE("alias-x86_32-v4l2_buffer") FEX_ANNOTATE("fex-match") fex_v4l2_buffer {
+    uint32_t index;
+    uint32_t type;
+    uint32_t bytesused;
+    uint32_t flags;
+    uint32_t field;
+    struct timeval32 timestamp;
+    struct v4l2_timecode timecode;
+    uint32_t sequence;
+    uint32_t memory;
+
+    union {
+      uint32_t offset;
+      compat_ptr<void> userptr;
+      compat_ptr<struct v4l2_plane> planes;
+      int32_t fd;
+    } m;
+    uint32_t length;
+    uint32_t reserved2;
+    union {
+      int32_t request_fd;
+      uint32_t reserved;
+    };
+
+    fex_v4l2_buffer() = delete;
+
+    operator v4l2_buffer() const {
+      v4l2_buffer val {};
+      CPYT(index);
+      CPYT(type);
+      CPYT(bytesused);
+      CPYT(flags);
+      CPYT(field);
+      CPYT(timestamp);
+      CPYT(timecode);
+      CPYT(sequence);
+      CPYT(memory);
+      CPYT(length);
+      CPYT(reserved2);
+      CPYT(m.offset);
+      CPYT(request_fd);
+      return val;
+    }
+
+    fex_v4l2_buffer(v4l2_buffer val)
+      : timestamp {val.timestamp}
+      , m {.offset = val.m.offset} {
+      CPYF(index);
+      CPYF(type);
+      CPYF(bytesused);
+      CPYF(flags);
+      CPYF(field);
+      CPYF(timecode);
+      CPYF(sequence);
+      CPYF(memory);
+      CPYF(length);
+      CPYF(reserved2);
+      CPYF(request_fd);
+    }
+  };
+
+  struct FEX_ANNOTATE("alias-x86_32-v4l2_framebuffer") FEX_ANNOTATE("fex-match") fex_v4l2_framebuffer {
+    uint32_t capability;
+    uint32_t flags;
+    compat_ptr<void> base;
+    struct {
+      uint32_t width;
+      uint32_t height;
+      uint32_t pixelformat;
+      uint32_t field;
+      uint32_t bytesperline;
+      uint32_t sizeimage;
+      uint32_t colorspace;
+      uint32_t priv;
+    } fmt;
+
+    fex_v4l2_framebuffer() = delete;
+
+    operator v4l2_framebuffer() const {
+      v4l2_framebuffer val {};
+      CPYT(capability);
+      CPYT(flags);
+      CPYT(base);
+      memcpy(&val.fmt, &fmt, sizeof(fmt));
+      return val;
+    }
+
+    fex_v4l2_framebuffer(v4l2_framebuffer val)
+      : base {auto_compat_ptr {val.base}} {
+      CPYF(capability);
+      CPYF(flags);
+      memcpy(&fmt, &val.fmt, sizeof(fmt));
+    }
+  };
+
+  struct FEX_ANNOTATE("alias-x86_32-v4l2_standard") FEX_ANNOTATE("fex-match") fex_v4l2_standard {
+    uint32_t index;
+    compat_uint64_t id;
+    uint8_t name[24];
+    struct v4l2_fract frameperiod;
+    uint32_t framelines;
+    uint32_t reserved[4];
+
+    fex_v4l2_standard() = delete;
+
+    operator v4l2_standard() const {
+      v4l2_standard val {};
+      CPYT(index);
+      CPYT(id);
+      memcpy(&val.name, name, sizeof(name));
+      CPYT(frameperiod);
+      CPYT(framelines);
+      memcpy(&val.reserved, reserved, sizeof(uint32_t) * 4);
+      return val;
+    }
+
+    fex_v4l2_standard(v4l2_standard val) {
+      CPYF(index);
+      CPYF(id);
+      memcpy(&name, val.name, sizeof(name));
+      CPYF(frameperiod);
+      CPYF(framelines);
+      memcpy(&reserved, val.reserved, sizeof(uint32_t) * 4);
+    }
+  };
+
+  struct FEX_ANNOTATE("alias-x86_32-v4l2_input") FEX_ANNOTATE("fex-match") fex_v4l2_input {
+    uint32_t index;
+    uint8_t name[32];
+    uint32_t type;
+    uint32_t audioset;
+    uint32_t tuner;
+    compat_uint64_t std;
+    uint32_t status;
+    uint32_t capabilities;
+    uint32_t reserved[3];
+
+    fex_v4l2_input() = delete;
+
+    operator v4l2_input() const {
+      v4l2_input val {};
+      CPYT(index);
+      memcpy(&val.name, &name, sizeof(name));
+      CPYT(type);
+      CPYT(audioset);
+      CPYT(tuner);
+      CPYT(std);
+      CPYT(status);
+      CPYT(capabilities);
+      memcpy(&val.reserved, &reserved, sizeof(uint32_t) * 3);
+      return val;
+    }
+
+    fex_v4l2_input(v4l2_input val) {
+      CPYF(index);
+      memcpy(&name, &val.name, sizeof(name));
+      CPYF(type);
+      CPYF(audioset);
+      CPYF(tuner);
+      CPYF(std);
+      CPYF(status);
+      CPYF(capabilities);
+      memcpy(&reserved, &val.reserved, sizeof(uint32_t) * 3);
+    }
+  };
+
+  struct FEX_ANNOTATE("alias-x86_32-v4l2_edid") FEX_ANNOTATE("fex-match") fex_v4l2_edid {
+    uint32_t pad;
+    uint32_t start_block;
+    uint32_t blocks;
+    uint32_t reserved[5];
+    compat_ptr<uint8_t> edid;
+
+    fex_v4l2_edid() = delete;
+
+    operator v4l2_edid() const {
+      v4l2_edid val {};
+      CPYT(pad);
+      CPYT(start_block);
+      CPYT(blocks);
+      memcpy(&val.reserved, &reserved, sizeof(uint32_t) * 5);
+      CPYT(edid);
+      return val;
+    }
+
+    fex_v4l2_edid(v4l2_edid val)
+      : edid {auto_compat_ptr {val.edid}} {
+      CPYF(pad);
+      CPYF(start_block);
+      CPYF(blocks);
+      memcpy(&reserved, &val.reserved, sizeof(uint32_t) * 5);
+    }
+  };
+
+  struct FEX_ANNOTATE("alias-x86_32-v4l2_ext_controls") FEX_ANNOTATE("fex-match") fex_v4l2_ext_controls {
+    union {
+      uint32_t ctrl_class;
+      uint32_t which;
+    };
+    uint32_t count;
+    uint32_t error_idx;
+    int32_t request_fd;
+    uint32_t reserved[1];
+    compat_ptr<struct v4l2_ext_control> controls;
+
+    fex_v4l2_ext_controls() = delete;
+
+    operator v4l2_ext_controls() const {
+      v4l2_ext_controls val {};
+      CPYT(which);
+      CPYT(count);
+      CPYT(error_idx);
+      CPYT(request_fd);
+      CPYT(reserved[0]);
+      CPYT(controls);
+      return val;
+    }
+
+    fex_v4l2_ext_controls(v4l2_ext_controls val)
+      : controls {auto_compat_ptr {val.controls}} {
+      CPYF(which);
+      CPYF(count);
+      CPYF(error_idx);
+      CPYF(request_fd);
+      CPYF(reserved[0]);
+    }
+  };
+
+  struct FEX_ANNOTATE("alias-x86_32-v4l2_event_ctrl") FEX_ANNOTATE("fex-match") fex_v4l2_event_ctrl {
+    uint32_t changes;
+    uint32_t type;
+    union {
+      int32_t value;
+      compat_int64_t value64;
+    };
+    uint32_t flags;
+    int32_t minimum;
+    int32_t maximum;
+    int32_t step;
+    int32_t default_value;
+
+    fex_v4l2_event_ctrl() = default;
+
+    operator v4l2_event_ctrl() const {
+      v4l2_event_ctrl val {};
+      CPYT(changes);
+      CPYT(type);
+      CPYT(value64);
+      CPYT(flags);
+      CPYT(minimum);
+      CPYT(maximum);
+      CPYT(step);
+      CPYT(default_value);
+      return val;
+    }
+
+    fex_v4l2_event_ctrl(v4l2_event_ctrl val) {
+      CPYF(changes);
+      CPYF(type);
+      CPYF(value64);
+      CPYF(flags);
+      CPYF(minimum);
+      CPYF(maximum);
+      CPYF(step);
+      CPYF(default_value);
+    }
+  };
+
+  struct FEX_ANNOTATE("alias-x86_32-v4l2_event") FEX_ANNOTATE("fex-match") fex_v4l2_event {
+    uint32_t type;
+    union {
+      struct v4l2_event_vsync vsync;
+      fex_v4l2_event_ctrl ctrl;
+      struct v4l2_event_frame_sync frame_sync;
+      struct v4l2_event_src_change src_change;
+      struct v4l2_event_motion_det motion_det;
+      uint8_t data[64];
+    } u;
+    uint32_t pending;
+    uint32_t sequence;
+    timespec32 timestamp;
+    uint32_t id;
+    uint32_t reserved[8];
+
+    fex_v4l2_event() = delete;
+
+    operator v4l2_event() const {
+      v4l2_event val {};
+      CPYT(type);
+      switch (type) {
+      case V4L2_EVENT_VSYNC: CPYT(u.vsync); break;
+      case V4L2_EVENT_CTRL: CPYT(u.ctrl); break;
+      case V4L2_EVENT_FRAME_SYNC: CPYT(u.frame_sync); break;
+      case V4L2_EVENT_SOURCE_CHANGE: CPYT(u.src_change); break;
+      case V4L2_EVENT_MOTION_DET: CPYT(u.motion_det); break;
+      default: memcpy(&val.u.data, &u.data, 64); break;
+      }
+      CPYT(pending);
+      CPYT(sequence);
+      CPYT(timestamp);
+      CPYT(id);
+      memcpy(&val.reserved, &reserved, sizeof(uint32_t) * 8);
+      return val;
+    }
+
+    fex_v4l2_event(v4l2_event val) {
+      CPYF(type);
+      switch (type) {
+      case V4L2_EVENT_VSYNC: CPYF(u.vsync); break;
+      case V4L2_EVENT_CTRL: CPYF(u.ctrl); break;
+      case V4L2_EVENT_FRAME_SYNC: CPYF(u.frame_sync); break;
+      case V4L2_EVENT_SOURCE_CHANGE: CPYF(u.src_change); break;
+      case V4L2_EVENT_MOTION_DET: CPYF(u.motion_det); break;
+      default: memcpy(&u.data, &val.u.data, 64); break;
+      }
+      CPYF(pending);
+      CPYF(sequence);
+      CPYF(timestamp);
+      CPYF(id);
+      memcpy(&reserved, &val.reserved, sizeof(uint32_t) * 8);
+    }
+  };
+
+  struct FEX_ANNOTATE("alias-x86_32-upstream_v4l2_create_buffers") FEX_ANNOTATE("fex-match") fex_v4l2_create_buffers {
+    uint32_t index;
+    uint32_t count;
+    uint32_t memory;
+    fex_v4l2_format format;
+    uint32_t capabilities;
+    uint32_t flags;
+    uint32_t max_num_buffers;
+    uint32_t reserved[5];
+
+    fex_v4l2_create_buffers() = delete;
+    operator upstream_v4l2_create_buffers() const {
+      upstream_v4l2_create_buffers val {};
+      CPYT(index);
+      CPYT(count);
+      CPYT(memory);
+      CPYT(format);
+      CPYT(capabilities);
+      CPYT(flags);
+      CPYT(max_num_buffers);
+      memcpy(&val.reserved, &reserved, sizeof(uint32_t) * 5);
+      return val;
+    }
+
+    fex_v4l2_create_buffers(upstream_v4l2_create_buffers val)
+      : format {val.format} {
+      CPYF(index);
+      CPYF(count);
+      CPYF(memory);
+      CPYF(capabilities);
+      CPYF(flags);
+      CPYF(max_num_buffers);
+      memcpy(&reserved, &val.reserved, sizeof(uint32_t) * 5);
+    }
+  };
+
 #include "LinuxSyscalls/x32/Ioctl/v4l2.inl"
 } // namespace V4l2
 } // namespace FEX::HLE::x32

Source/Tools/LinuxEmulation/LinuxSyscalls/x32/Ioctl/v4l2.inl

@@ -1,10 +1,87 @@
-// Should be enough for wine/proton to works well.
-_BASIC_META(VIDIOC_G_CTRL)
-_BASIC_META(VIDIOC_S_CTRL)
-_BASIC_META(VIDIOC_QUERYCTRL)
+#ifndef VIDIOC_REMOVE_BUFS
+#define VIDIOC_REMOVE_BUFS _IOWR('V', 104, struct upstream_v4l2_remove_buffers)
+#endif
+
 _BASIC_META(VIDIOC_QUERYCAP)
-_BASIC_META(VIDIOC_ENUM_FRAMESIZES)
-_BASIC_META(VIDIOC_ENUM_FRAMEINTERVALS)
+_BASIC_META(VIDIOC_ENUM_FMT)
 _CUSTOM_META(VIDIOC_G_FMT, _IOWR('V', 4, FEX::HLE::x32::V4l2::fex_v4l2_format))
 _CUSTOM_META(VIDIOC_S_FMT, _IOWR('V', 5, FEX::HLE::x32::V4l2::fex_v4l2_format))
+_BASIC_META(VIDIOC_REQBUFS)
+_CUSTOM_META(VIDIOC_QUERYBUF, _IOWR('V',  9, FEX::HLE::x32::V4l2::fex_v4l2_buffer))
+_CUSTOM_META(VIDIOC_G_FBUF, _IOR('V', 10, FEX::HLE::x32::V4l2::fex_v4l2_framebuffer))
+_CUSTOM_META(VIDIOC_S_FBUF, _IOW('V', 11, FEX::HLE::x32::V4l2::fex_v4l2_framebuffer))
+_BASIC_META(VIDIOC_OVERLAY)
+_CUSTOM_META(VIDIOC_QBUF, _IOWR('V', 15, FEX::HLE::x32::V4l2::fex_v4l2_buffer))
+_BASIC_META(VIDIOC_EXPBUF)
+_CUSTOM_META(VIDIOC_DQBUF, _IOWR('V', 17, FEX::HLE::x32::V4l2::fex_v4l2_buffer))
+_BASIC_META(VIDIOC_STREAMON)
+_BASIC_META(VIDIOC_STREAMOFF)
+_BASIC_META(VIDIOC_G_PARM)
+_BASIC_META(VIDIOC_S_PARM)
+_BASIC_META(VIDIOC_G_STD)
+_BASIC_META(VIDIOC_S_STD)
+_CUSTOM_META(VIDIOC_ENUMSTD, _IOWR('V', 25, FEX::HLE::x32::V4l2::fex_v4l2_standard))
+_CUSTOM_META(VIDIOC_ENUMINPUT, _IOWR('V', 26, FEX::HLE::x32::V4l2::fex_v4l2_input))
+_BASIC_META(VIDIOC_G_CTRL)
+_BASIC_META(VIDIOC_S_CTRL)
+_BASIC_META(VIDIOC_G_TUNER)
+_BASIC_META(VIDIOC_S_TUNER)
+_BASIC_META(VIDIOC_G_AUDIO)
+_BASIC_META(VIDIOC_S_AUDIO)
+_BASIC_META(VIDIOC_QUERYCTRL)
+_BASIC_META(VIDIOC_QUERYMENU)
+_BASIC_META(VIDIOC_G_INPUT)
+_BASIC_META(VIDIOC_S_INPUT)
+_CUSTOM_META(VIDIOC_G_EDID, _IOWR('V', 40, FEX::HLE::x32::V4l2::fex_v4l2_edid))
+_CUSTOM_META(VIDIOC_S_EDID, _IOWR('V', 41, FEX::HLE::x32::V4l2::fex_v4l2_edid))
+_BASIC_META(VIDIOC_G_OUTPUT)
+_BASIC_META(VIDIOC_S_OUTPUT)
+_BASIC_META(VIDIOC_ENUMOUTPUT)
+_BASIC_META(VIDIOC_G_AUDOUT)
+_BASIC_META(VIDIOC_S_AUDOUT)
+_BASIC_META(VIDIOC_G_MODULATOR)
+_BASIC_META(VIDIOC_S_MODULATOR)
+_BASIC_META(VIDIOC_G_FREQUENCY)
+_BASIC_META(VIDIOC_S_FREQUENCY)
+_BASIC_META(VIDIOC_CROPCAP)
+_BASIC_META(VIDIOC_G_CROP)
+_BASIC_META(VIDIOC_S_CROP)
+_BASIC_META(VIDIOC_G_JPEGCOMP)
+_BASIC_META(VIDIOC_S_JPEGCOMP)
+_BASIC_META(VIDIOC_QUERYSTD)
 _CUSTOM_META(VIDIOC_TRY_FMT, _IOWR('V', 64, FEX::HLE::x32::V4l2::fex_v4l2_format))
+_BASIC_META(VIDIOC_ENUMAUDIO)
+_BASIC_META(VIDIOC_ENUMAUDOUT)
+_BASIC_META(VIDIOC_G_PRIORITY)
+_BASIC_META(VIDIOC_S_PRIORITY)
+_BASIC_META(VIDIOC_G_SLICED_VBI_CAP)
+_BASIC_META(VIDIOC_LOG_STATUS)
+_CUSTOM_META(VIDIOC_G_EXT_CTRLS, _IOWR('V', 71, FEX::HLE::x32::V4l2::fex_v4l2_ext_controls))
+_CUSTOM_META(VIDIOC_S_EXT_CTRLS, _IOWR('V', 72, FEX::HLE::x32::V4l2::fex_v4l2_ext_controls))
+_CUSTOM_META(VIDIOC_TRY_EXT_CTRLS, _IOWR('V', 73, FEX::HLE::x32::V4l2::fex_v4l2_ext_controls))
+_BASIC_META(VIDIOC_ENUM_FRAMESIZES)
+_BASIC_META(VIDIOC_ENUM_FRAMEINTERVALS)
+_BASIC_META(VIDIOC_G_ENC_INDEX)
+_BASIC_META(VIDIOC_ENCODER_CMD)
+_BASIC_META(VIDIOC_TRY_ENCODER_CMD)
+_BASIC_META(VIDIOC_DBG_S_REGISTER)
+_BASIC_META(VIDIOC_DBG_G_REGISTER)
+_BASIC_META(VIDIOC_S_HW_FREQ_SEEK)
+_BASIC_META(VIDIOC_S_DV_TIMINGS)
+_BASIC_META(VIDIOC_G_DV_TIMINGS)
+_CUSTOM_META(VIDIOC_DQEVENT,  _IOR('V', 89, FEX::HLE::x32::V4l2::fex_v4l2_event))
+_BASIC_META(VIDIOC_SUBSCRIBE_EVENT)
+_BASIC_META(VIDIOC_UNSUBSCRIBE_EVENT)
+_CUSTOM_META(VIDIOC_CREATE_BUFS, _IOWR('V', 92, FEX::HLE::x32::V4l2::fex_v4l2_create_buffers))
+_CUSTOM_META(VIDIOC_PREPARE_BUF, _IOWR('V', 93, FEX::HLE::x32::V4l2::fex_v4l2_buffer))
+_BASIC_META(VIDIOC_G_SELECTION)
+_BASIC_META(VIDIOC_S_SELECTION)
+_BASIC_META(VIDIOC_DECODER_CMD)
+_BASIC_META(VIDIOC_TRY_DECODER_CMD)
+_BASIC_META(VIDIOC_ENUM_DV_TIMINGS)
+_BASIC_META(VIDIOC_QUERY_DV_TIMINGS)
+_BASIC_META(VIDIOC_DV_TIMINGS_CAP)
+_BASIC_META(VIDIOC_ENUM_FREQ_BANDS)
+_BASIC_META(VIDIOC_DBG_G_CHIP_INFO)
+_BASIC_META(VIDIOC_QUERY_EXT_CTRL)
+_BASIC_META(VIDIOC_REMOVE_BUFS)

Source/Tools/LinuxEmulation/LinuxSyscalls/x32/IoctlEmulation.cpp

@@ -74,6 +74,105 @@ namespace V4l2 {
       SYSCALL_ERRNO();
       break;
     }
+    case _IOC_NR(FEX_VIDIOC_QUERYBUF): {
+      auto format = reinterpret_cast<fex_v4l2_buffer*>(args);
+      v4l2_buffer Host_format = *format;
+
+      uint64_t Result = ::ioctl(fd, VIDIOC_QUERYBUF, &Host_format);
+      if (Result != -1) {
+        *format = Host_format;
+      }
+      SYSCALL_ERRNO();
+      break;
+    }
+    case _IOC_NR(FEX_VIDIOC_G_FBUF): {
+      auto format = reinterpret_cast<fex_v4l2_framebuffer*>(args);
+      v4l2_framebuffer Host_format = *format;
+
+      uint64_t Result = ::ioctl(fd, VIDIOC_G_FBUF, &Host_format);
+      if (Result != -1) {
+        *format = Host_format;
+      }
+      SYSCALL_ERRNO();
+      break;
+    }
+    case _IOC_NR(FEX_VIDIOC_S_FBUF): {
+      auto format = reinterpret_cast<fex_v4l2_framebuffer*>(args);
+      v4l2_framebuffer Host_format = *format;
+
+      uint64_t Result = ::ioctl(fd, VIDIOC_S_FBUF, &Host_format);
+      if (Result != -1) {
+        *format = Host_format;
+      }
+      SYSCALL_ERRNO();
+      break;
+    }
+    case _IOC_NR(FEX_VIDIOC_QBUF): {
+      auto format = reinterpret_cast<fex_v4l2_buffer*>(args);
+      v4l2_buffer Host_format = *format;
+
+      uint64_t Result = ::ioctl(fd, VIDIOC_QBUF, &Host_format);
+      if (Result != -1) {
+        *format = Host_format;
+      }
+      SYSCALL_ERRNO();
+      break;
+    }
+    case _IOC_NR(FEX_VIDIOC_DQBUF): {
+      auto format = reinterpret_cast<fex_v4l2_buffer*>(args);
+      v4l2_buffer Host_format = *format;
+
+      uint64_t Result = ::ioctl(fd, VIDIOC_DQBUF, &Host_format);
+      if (Result != -1) {
+        *format = Host_format;
+      }
+      SYSCALL_ERRNO();
+      break;
+    }
+    case _IOC_NR(FEX_VIDIOC_ENUMSTD): {
+      auto format = reinterpret_cast<fex_v4l2_standard*>(args);
+      v4l2_standard Host_format = *format;
+
+      uint64_t Result = ::ioctl(fd, VIDIOC_ENUMSTD, &Host_format);
+      if (Result != -1) {
+        *format = Host_format;
+      }
+      SYSCALL_ERRNO();
+      break;
+    }
+    case _IOC_NR(FEX_VIDIOC_ENUMINPUT): {
+      auto format = reinterpret_cast<fex_v4l2_input*>(args);
+      v4l2_input Host_format = *format;
+
+      uint64_t Result = ::ioctl(fd, VIDIOC_ENUMINPUT, &Host_format);
+      if (Result != -1) {
+        *format = Host_format;
+      }
+      SYSCALL_ERRNO();
+      break;
+    }
+    case _IOC_NR(FEX_VIDIOC_G_EDID): {
+      auto format = reinterpret_cast<fex_v4l2_edid*>(args);
+      v4l2_edid Host_format = *format;
+
+      uint64_t Result = ::ioctl(fd, VIDIOC_G_EDID, &Host_format);
+      if (Result != -1) {
+        *format = Host_format;
+      }
+      SYSCALL_ERRNO();
+      break;
+    }
+    case _IOC_NR(FEX_VIDIOC_S_EDID): {
+      auto format = reinterpret_cast<fex_v4l2_edid*>(args);
+      v4l2_edid Host_format = *format;
+
+      uint64_t Result = ::ioctl(fd, VIDIOC_S_EDID, &Host_format);
+      if (Result != -1) {
+        *format = Host_format;
+      }
+      SYSCALL_ERRNO();
+      break;
+    }
     case _IOC_NR(FEX_VIDIOC_TRY_FMT): {
       fex_v4l2_format* format = reinterpret_cast<fex_v4l2_format*>(args);
       v4l2_format Host_format = *format;
@@ -88,6 +187,72 @@ namespace V4l2 {
       SYSCALL_ERRNO();
       break;
     }
+    case _IOC_NR(FEX_VIDIOC_G_EXT_CTRLS): {
+      auto format = reinterpret_cast<fex_v4l2_ext_controls*>(args);
+      v4l2_ext_controls Host_format = *format;
+
+      uint64_t Result = ::ioctl(fd, VIDIOC_G_EXT_CTRLS, &Host_format);
+      if (Result != -1) {
+        *format = Host_format;
+      }
+      SYSCALL_ERRNO();
+      break;
+    }
+    case _IOC_NR(FEX_VIDIOC_S_EXT_CTRLS): {
+      auto format = reinterpret_cast<fex_v4l2_ext_controls*>(args);
+      v4l2_ext_controls Host_format = *format;
+
+      uint64_t Result = ::ioctl(fd, VIDIOC_S_EXT_CTRLS, &Host_format);
+      if (Result != -1) {
+        *format = Host_format;
+      }
+      SYSCALL_ERRNO();
+      break;
+    }
+    case _IOC_NR(FEX_VIDIOC_TRY_EXT_CTRLS): {
+      auto format = reinterpret_cast<fex_v4l2_ext_controls*>(args);
+      v4l2_ext_controls Host_format = *format;
+
+      uint64_t Result = ::ioctl(fd, VIDIOC_TRY_EXT_CTRLS, &Host_format);
+      if (Result != -1) {
+        *format = Host_format;
+      }
+      SYSCALL_ERRNO();
+      break;
+    }
+    case _IOC_NR(FEX_VIDIOC_DQEVENT): {
+      auto format = reinterpret_cast<fex_v4l2_event*>(args);
+      v4l2_event Host_format = *format;
+
+      uint64_t Result = ::ioctl(fd, VIDIOC_DQEVENT, &Host_format);
+      if (Result != -1) {
+        *format = Host_format;
+      }
+      SYSCALL_ERRNO();
+      break;
+    }
+    case _IOC_NR(FEX_VIDIOC_CREATE_BUFS): {
+      auto format = reinterpret_cast<fex_v4l2_create_buffers*>(args);
+      upstream_v4l2_create_buffers Host_format = *format;
+
+      uint64_t Result = ::ioctl(fd, VIDIOC_CREATE_BUFS, &Host_format);
+      if (Result != -1) {
+        *format = Host_format;
+      }
+      SYSCALL_ERRNO();
+      break;
+    }
+    case _IOC_NR(FEX_VIDIOC_PREPARE_BUF): {
+      auto format = reinterpret_cast<fex_v4l2_buffer*>(args);
+      v4l2_buffer Host_format = *format;
+
+      uint64_t Result = ::ioctl(fd, VIDIOC_PREPARE_BUF, &Host_format);
+      if (Result != -1) {
+        *format = Host_format;
+      }
+      SYSCALL_ERRNO();
+      break;
+    }
 #define _BASIC_META(x) case _IOC_NR(x):
 #define _BASIC_META_VAR(x, args...) case _IOC_NR(x):
 #define _CUSTOM_META(name, ioctl_num)