From: Mattijs Korpershoek <mkorpershoek@kernel.org>
To: Hans Verkuil <hverkuil+cisco@kernel.org>,
Laurent Pinchart <laurent.pinchart@ideasonboard.com>,
Kieran Bingham <kieran.bingham@ideasonboard.com>,
Sakari Ailus <sakari.ailus@linux.intel.com>,
Mauro Carvalho Chehab <mchehab@kernel.org>,
Andy Walls <awalls@md.metrocast.net>,
Kees Cook <kees@kernel.org>,
"Gustavo A. R. Silva" <gustavoars@kernel.org>
Cc: Mattijs Korpershoek <mkorpershoek@kernel.org>,
Nicolas Dufresne <nicolas.dufres@collabora.com>,
Hans de Goede <hansg@kernel.org>,
Michael Riesch <michael.riesch@collabora.com>,
Dave Stevenson <dave.stevenson@raspberrypi.com>,
Maxime Ripard <mripard@kernel.org>,
linux-media@vger.kernel.org, linux-kernel@vger.kernel.org,
linux-hardening@vger.kernel.org
Subject: [PATCH RFC v2 07/16] media: mc: Add MEDIA_IOC_DQEVENT
Date: Wed, 18 Nov 2026 13:43:51 +0100 [thread overview]
Message-ID: <20261118-v4l2-sensor-detect-v2-7-1bb1a445b556@kernel.org> (raw)
In-Reply-To: <20261118-v4l2-sensor-detect-v2-0-1bb1a445b556@kernel.org>
From: Sakari Ailus <sakari.ailus@linux.intel.com>
Events on a media device tell about completion of requests. Blocking and
non-blocking operation is supported.
Signed-off-by: Sakari Ailus <sakari.ailus@linux.intel.com>
Signed-off-by: Mattijs Korpershoek <mkorpershoek@kernel.org>
---
drivers/media/Kconfig | 1 +
drivers/media/mc/Makefile | 2 +-
drivers/media/mc/mc-device.c | 48 +++++++++
drivers/media/mc/mc-event.c | 244 +++++++++++++++++++++++++++++++++++++++++++
include/media/media-device.h | 3 +
include/media/media-event.h | 181 ++++++++++++++++++++++++++++++++
include/media/media-fh.h | 5 +
include/uapi/linux/media.h | 24 +++++
8 files changed, 507 insertions(+), 1 deletion(-)
diff --git a/drivers/media/Kconfig b/drivers/media/Kconfig
index 70e090757492..5ffcd5565bd1 100644
--- a/drivers/media/Kconfig
+++ b/drivers/media/Kconfig
@@ -12,6 +12,7 @@ source "drivers/media/cec/Kconfig"
menuconfig MEDIA_SUPPORT
tristate "Multimedia support"
depends on HAS_IOMEM
+ select MEDIA_EVENT
help
If you want to use media devices, including Webcams, Video grabber
devices and/or TV devices, V4L2 codecs, etc, enable this option
diff --git a/drivers/media/mc/Makefile b/drivers/media/mc/Makefile
index d501327436a5..1e6540161e0c 100644
--- a/drivers/media/mc/Makefile
+++ b/drivers/media/mc/Makefile
@@ -1,7 +1,7 @@
# SPDX-License-Identifier: GPL-2.0
mc-objs := mc-device.o mc-devnode.o mc-entity.o \
- mc-request.o
+ mc-request.o mc-event.o
ifneq ($(CONFIG_USB),)
mc-objs += mc-dev-allocator.o
diff --git a/drivers/media/mc/mc-device.c b/drivers/media/mc/mc-device.c
index b64322efd99e..98d323c89b41 100644
--- a/drivers/media/mc/mc-device.c
+++ b/drivers/media/mc/mc-device.c
@@ -8,6 +8,7 @@
* Sakari Ailus <sakari.ailus@iki.fi>
*/
+#include <linux/atomic.h>
#include <linux/compat.h>
#include <linux/export.h>
#include <linux/idr.h>
@@ -22,6 +23,7 @@
#include <media/media-device.h>
#include <media/media-devnode.h>
#include <media/media-entity.h>
+#include <media/media-event.h>
#include <media/media-fh.h>
#include <media/media-request.h>
@@ -57,6 +59,14 @@ static int media_device_open(struct file *filp)
return -ENOMEM;
filp->private_data = &fh->fh;
+ init_waitqueue_head(&fh->wait);
+
+ fh->ev_fh.lock = &mdev->fh_list_lock;
+ fh->ev_fh.wait = &fh->wait;
+ INIT_LIST_HEAD(&fh->ev_fh.available);
+ INIT_LIST_HEAD(&fh->ev_fh.subscribed);
+ fh->ev_fh.sequence = -1;
+ mutex_init(&fh->ev_fh.subscribe_lock);
spin_lock_irqsave(&mdev->fh_list_lock, flags);
list_add(&fh->mdev_list, &mdev->fh_list);
@@ -78,6 +88,9 @@ static int media_device_close(struct file *filp)
spin_unlock_irqrestore(&mdev->fh_list_lock, flags);
}
+ media_event_unsubscribe_all(fh);
+ mutex_destroy(&fh->ev_fh.subscribe_lock);
+
kfree(fh);
return 0;
@@ -414,6 +427,25 @@ static long media_device_request_alloc(struct media_device *mdev,
return media_request_alloc(mdev, alloc_fd);
}
+static long media_device_event_dequeue(struct media_device *mdev,
+ struct file *file, void *arg)
+{
+ return media_event_dequeue(media_device_fh(file), arg,
+ file->f_flags & O_NONBLOCK);
+}
+
+static long media_device_event_subscribe(struct media_device *mdev,
+ struct file *file, void *arg)
+{
+ return media_event_subscribe(media_device_fh(file), arg, 0, NULL);
+}
+
+static long media_device_event_unsubscribe(struct media_device *mdev,
+ struct file *file, void *arg)
+{
+ return media_event_unsubscribe(media_device_fh(file), arg);
+}
+
static long copy_arg_from_user(void *karg, void __user *uarg, unsigned int cmd)
{
if ((_IOC_DIR(cmd) & _IOC_WRITE) &&
@@ -464,6 +496,9 @@ static const struct media_ioctl_info ioctl_info[] = {
MEDIA_IOC(SETUP_LINK, media_device_setup_link, MEDIA_IOC_FL_GRAPH_MUTEX),
MEDIA_IOC(G_TOPOLOGY, media_device_get_topology, MEDIA_IOC_FL_GRAPH_MUTEX),
MEDIA_IOC(REQUEST_ALLOC, media_device_request_alloc, 0),
+ MEDIA_IOC(DQEVENT, media_device_event_dequeue, 0),
+ MEDIA_IOC(SUBSCRIBE_EVENT, media_device_event_subscribe, 0),
+ MEDIA_IOC(UNSUBSCRIBE_EVENT, media_device_event_unsubscribe, 0),
};
static long media_device_ioctl(struct file *filp, unsigned int cmd,
@@ -574,9 +609,22 @@ static long media_device_compat_ioctl(struct file *filp, unsigned int cmd,
}
#endif /* CONFIG_COMPAT */
+static __poll_t media_device_poll(struct file *filp,
+ struct poll_table_struct *wait)
+{
+ struct media_device_fh *fh = media_device_fh(filp);
+
+ poll_wait(filp, &fh->wait, wait);
+ if (media_event_pending(fh))
+ return EPOLLPRI;
+
+ return 0;
+}
+
static const struct media_file_operations media_device_fops = {
.owner = THIS_MODULE,
.open = media_device_open,
+ .poll = media_device_poll,
.ioctl = media_device_ioctl,
#ifdef CONFIG_COMPAT
.compat_ioctl = media_device_compat_ioctl,
diff --git a/drivers/media/mc/mc-event.c b/drivers/media/mc/mc-event.c
new file mode 100644
index 000000000000..2369e40e522f
--- /dev/null
+++ b/drivers/media/mc/mc-event.c
@@ -0,0 +1,244 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * Media events
+ *
+ * Copyright (C) 2019, 2026 Intel Corporation
+ * Copyright (C) 2009--2010 Nokia Corporation.
+ *
+ * Based on V4L2 events in drivers/media/v4l2-core/v4l2-events.c .
+ */
+
+#include <linux/mm.h>
+#include <linux/sched.h>
+#include <linux/slab.h>
+#include <linux/export.h>
+
+#include <media/media-device.h>
+#include <media/media-event.h>
+#include <media/media-fh.h>
+
+static int media_evop_add(struct media_subscribed_evbase *mse, unsigned int elems)
+{
+ struct media_subscribed_event *sev = to_media_subscribed_event(mse);
+
+ if (sev->ops && sev->ops->add)
+ return sev->ops->add(sev, elems);
+
+ return 0;
+}
+
+static void media_evop_del(struct media_subscribed_evbase *mse)
+{
+ struct media_subscribed_event *sev = to_media_subscribed_event(mse);
+
+ if (sev->ops && sev->ops->del)
+ sev->ops->del(sev);
+}
+
+static bool media_evop_replace(struct media_subscribed_evbase *mse,
+ struct media_evbase *old,
+ const void *new)
+{
+ struct media_subscribed_event *sev = to_media_subscribed_event(mse);
+
+ if (sev->ops && sev->ops->replace) {
+ sev->ops->replace(&to_media_kevent(old)->event, new);
+ return true;
+ }
+
+ return false;
+}
+
+static void media_evop_merge(struct media_subscribed_evbase *mse,
+ const struct media_evbase *old,
+ struct media_evbase *new)
+{
+ struct media_subscribed_event *sev = to_media_subscribed_event(mse);
+
+ if (sev->ops && sev->ops->merge)
+ sev->ops->merge(&to_media_kevent_const(old)->event,
+ &to_media_kevent(new)->event);
+}
+
+static void media_evop_queue(struct media_evbase *kev, const void *__ev,
+ u64 ts, u32 sequence, bool copy_payload)
+{
+ struct media_event *old = &to_media_kevent(kev)->event;
+ const struct media_event *new = __ev;
+
+ old->type = new->type;
+ if (copy_payload)
+ old->u = new->u;
+ old->id = new->id;
+ old->timestamp = ts;
+ old->sequence = sequence;
+}
+
+static bool media_evop_is_subscribed(struct media_subscribed_evbase *mse,
+ const void *__evspec)
+{
+ const struct media_event_spec *evspec = __evspec;
+ struct media_subscribed_event *sev =
+ container_of(mse, struct media_subscribed_event, mse);
+
+ return sev->evspec.type == evspec->type &&
+ sev->evspec.id == evspec->id;
+}
+
+static bool media_evop_is_queueable(struct media_subscribed_evbase *mse,
+ const void *__ev)
+{
+ const struct media_event *ev = __ev;
+ struct media_subscribed_event *sev =
+ container_of(mse, struct media_subscribed_event, mse);
+
+ return sev->evspec.type == ev->type && sev->evspec.id == ev->id;
+}
+
+static void media_evop_release(struct media_subscribed_evbase *mse)
+{
+ kvfree(to_media_subscribed_event(mse));
+}
+
+static const struct media_subscribed_evbase_ops media_event_ops = {
+ .add = media_evop_add,
+ .del = media_evop_del,
+ .replace = media_evop_replace,
+ .merge = media_evop_merge,
+ .queue = media_evop_queue,
+ .is_subscribed = media_evop_is_subscribed,
+ .is_queueable = media_evop_is_queueable,
+ .release = media_evop_release,
+};
+
+static int __media_event_dequeue(struct media_evbase_fh *fh,
+ struct media_event *event)
+{
+ struct media_evbase *mev;
+ struct media_kevent *kev;
+ unsigned long flags;
+
+ spin_lock_irqsave(fh->lock, flags);
+
+ mev = __media_evbase_dequeue(fh);
+ if (!mev) {
+ spin_unlock_irqrestore(fh->lock, flags);
+ return -ENOENT;
+ }
+
+ kev = container_of(mev, struct media_kevent, mev);
+
+ *event = kev->event;
+ event->pending = fh->navailable;
+
+ spin_unlock_irqrestore(fh->lock, flags);
+
+ return 0;
+}
+
+long media_event_dequeue(struct media_device_fh *fh, struct media_event *event,
+ int nonblocking)
+{
+ int ret;
+
+ if (nonblocking)
+ return __media_event_dequeue(&fh->ev_fh, event);
+
+ do {
+ ret = wait_event_interruptible(fh->wait,
+ fh->ev_fh.navailable != 0);
+ if (ret < 0)
+ break;
+
+ ret = __media_event_dequeue(&fh->ev_fh, event);
+ } while (ret == -ENOENT);
+
+ return ret;
+}
+EXPORT_SYMBOL_GPL(media_event_dequeue);
+
+void media_event_queue(struct media_device *mdev, const struct media_event *ev)
+{
+ struct media_device_fh *fh;
+ unsigned long flags;
+ u64 ts;
+
+ if (mdev == NULL)
+ return;
+
+ ts = ktime_get_ns();
+
+ spin_lock_irqsave(&mdev->fh_list_lock, flags);
+
+ list_for_each_entry(fh, &mdev->fh_list, mdev_list)
+ __media_evbase_queue_fh(&fh->ev_fh, ev, ts);
+
+ spin_unlock_irqrestore(&mdev->fh_list_lock, flags);
+}
+EXPORT_SYMBOL_GPL(media_event_queue);
+
+int media_event_pending(struct media_device_fh *fh)
+{
+ return media_evbase_pending(&fh->ev_fh);
+}
+EXPORT_SYMBOL_GPL(media_event_pending);
+
+long media_event_subscribe(struct media_device_fh *fh,
+ const struct media_event_subscription *sub,
+ unsigned int elems,
+ const struct media_subscribed_event_ops *ops)
+{
+ struct media_subscribed_evbase *mse;
+ struct media_subscribed_event *sev;
+
+ if (sub->type == MEDIA_EVENT_ALL)
+ return -EINVAL;
+
+ elems = max(elems, 1U);
+
+ sev = kvzalloc(sizeof(*sev) + array_size(sizeof(struct media_kevent),
+ elems), GFP_KERNEL);
+ if (!sev)
+ return -ENOMEM;
+
+ sev->evspec.type = sub->type;
+ sev->evspec.id = sub->id;
+ sev->evspec.flags = sub->flags;
+ sev->ops = ops;
+
+ mse = &sev->mse;
+
+ mse->ev_size = sizeof(struct media_kevent);
+ mse->ops = &media_event_ops;
+ mse->fh = &fh->ev_fh;
+ mse->evspec = &sev->evspec;
+
+ return media_evbase_subscribe(&fh->ev_fh, mse, elems);
+}
+EXPORT_SYMBOL_GPL(media_event_subscribe);
+
+void media_event_unsubscribe_all(struct media_device_fh *fh)
+{
+ media_evbase_unsubscribe_all(&fh->ev_fh);
+}
+EXPORT_SYMBOL_GPL(media_event_unsubscribe_all);
+
+long media_event_unsubscribe(struct media_device_fh *fh,
+ const struct media_event_subscription *sub)
+{
+ struct media_event_spec evspec = {
+ .type = sub->type,
+ .id = sub->id,
+ .flags = sub->flags,
+ };
+
+ if (sub->type == MEDIA_EVENT_ALL) {
+ media_event_unsubscribe_all(fh);
+ return 0;
+ }
+
+ media_evbase_unsubscribe(&fh->ev_fh, &evspec);
+
+ return 0;
+}
+EXPORT_SYMBOL_GPL(media_event_unsubscribe);
diff --git a/include/media/media-device.h b/include/media/media-device.h
index 2e737fec1afc..3ef277309d59 100644
--- a/include/media/media-device.h
+++ b/include/media/media-device.h
@@ -19,10 +19,13 @@
#include <media/media-devnode.h>
#include <media/media-entity.h>
+#include <media/media-evbase.h>
struct ida;
struct media_device;
+#include <uapi/linux/media.h>
+
/**
* struct media_entity_notify - Media Entity Notify
*
diff --git a/include/media/media-event.h b/include/media/media-event.h
new file mode 100644
index 000000000000..57265d117cf5
--- /dev/null
+++ b/include/media/media-event.h
@@ -0,0 +1,181 @@
+/* SPDX-License-Identifier: GPL-2.0-only */
+/*
+ * media-event.h
+ *
+ * Media controller events.
+ *
+ * Copyright (C) 2019, 2026 Intel Corporation
+ * Copyright (C) 2009--2010 Nokia Corporation.
+ *
+ * Based on V4L2 events.
+ */
+
+#ifndef MEDIA_EVENT_H
+#define MEDIA_EVENT_H
+
+#include <linux/types.h>
+#include <linux/media.h>
+
+#include <media/media-evbase.h>
+
+struct media_device;
+struct media_device_fh;
+struct media_subscribed_event;
+
+/**
+ * struct media_event_spec - Event subscription parameters
+ *
+ * @type: Media event type, MEDIA_EVENT_*.
+ * @id: Media event id.
+ * @flags: Media event flags.
+ */
+struct media_event_spec {
+ u32 type;
+ u32 id;
+ u32 flags;
+};
+
+/**
+ * struct media_subscribed_event_ops - Subscribed event operations.
+ *
+ * @add: Optional callback, called when a new listener is added
+ * @del: Optional callback, called when a listener stops listening
+ * @replace: Optional callback that can replace event 'old' with event 'new'.
+ * @merge: Optional callback that can merge event 'old' into event 'new'.
+ */
+struct media_subscribed_event_ops {
+ int (*add)(struct media_subscribed_event *sev, unsigned int elems);
+ void (*del)(struct media_subscribed_event *sev);
+ void (*replace)(struct media_event *old, const struct media_event *new);
+ void (*merge)(const struct media_event *old, struct media_event *new);
+};
+
+/**
+ * struct media_subscribed_event - Describes a single subscribed media event.
+ *
+ * @evspec: Parameters of the subscribed event.
+ * @ops: Operations for the subscribed event.
+ * @mse: Common media event descriptor.
+ */
+struct media_subscribed_event {
+ struct media_event_spec evspec;
+ const struct media_subscribed_event_ops *ops;
+ struct media_subscribed_evbase mse;
+};
+
+/**
+ * struct media_kevent - Internal kernel event struct.
+ *
+ * @mev: Generic media subsystem kernel event.
+ * @event: The media event itself.
+ */
+struct media_kevent {
+ struct media_evbase mev;
+ struct media_event event;
+};
+
+/**
+ * to_media_kevent - Convert a generic media_evbase into a media_kevent
+ *
+ * @mev: The generic media event
+ */
+static inline struct media_kevent *to_media_kevent(struct media_evbase *mev)
+{
+ return container_of(mev, struct media_kevent, mev);
+}
+
+/**
+ * to_media_kevent_const - Convert a const generic media_evbase into a
+ * media_kevent
+ *
+ * @mev: The generic media event
+ *
+ * This is just like @to_media_kevent, but const.
+ */
+static inline const struct media_kevent *
+to_media_kevent_const(const struct media_evbase *mev)
+{
+ return container_of(mev, const struct media_kevent, mev);
+}
+
+/**
+ * to_media_subscribed_event - Convert a generic media_subscribed_evbase into
+ * a media_subscribed_event.
+ *
+ * @mse: The generic media subscribed event base
+ */
+static inline struct media_subscribed_event *
+to_media_subscribed_event(struct media_subscribed_evbase *mse)
+{
+ return container_of(mse, struct media_subscribed_event, mse);
+}
+
+/**
+ * media_event_dequeue - Dequeue events from a media device.
+ *
+ * @fh: pointer to struct media_device_fh
+ * @event: pointer to struct media_event
+ * @nonblocking: if zero, wait for an event to arrive
+ */
+long media_event_dequeue(struct media_device_fh *fh,
+ struct media_event *event, int nonblocking);
+
+/**
+ * media_event_queue - Queue events to a media device.
+ *
+ * @mdev: pointer to &struct media_device
+ * @ev: pointer to &struct media_event
+ *
+ * The event will be queued for all &struct media_device_fh file handlers.
+ *
+ * .. note::
+ * The driver's only responsibility is to fill in the type and the data
+ * fields. The other fields will be filled in by the framework.
+ */
+void media_event_queue(struct media_device *mdev,
+ const struct media_event *ev);
+
+/**
+ * media_event_pending - Check if an event is available
+ *
+ * @fh: pointer to &struct media_device_fh
+ *
+ * Returns the number of pending events.
+ */
+int media_event_pending(struct media_device_fh *fh);
+
+/**
+ * media_event_subscribe - Subscribes to a media event.
+ *
+ * @fh: pointer to &struct media_device_fh
+ * @sub: pointer to &struct media_event_subscription
+ * @elems: size of the events queue
+ * @ops: pointer to &media_subscribed_event_ops
+ *
+ * .. note::
+ *
+ * if @elems is zero, the framework will fill in a default value,
+ * which is currently 1 element.
+ */
+long media_event_subscribe(struct media_device_fh *fh,
+ const struct media_event_subscription *sub,
+ unsigned int elems,
+ const struct media_subscribed_event_ops *ops);
+
+/**
+ * media_event_unsubscribe - Unsubscribe from a media event.
+ *
+ * @fh: pointer to &struct media_device_fh
+ * @sub: pointer to &struct media_event_subscription
+ */
+long media_event_unsubscribe(struct media_device_fh *fh,
+ const struct media_event_subscription *sub);
+
+/**
+ * media_event_unsubscribe_all - Unsubscribe from all media events.
+ *
+ * @fh: pointer to &struct media_device_fh
+ */
+void media_event_unsubscribe_all(struct media_device_fh *fh);
+
+#endif /* MEDIA_EVENT_H */
diff --git a/include/media/media-fh.h b/include/media/media-fh.h
index 14ae4daaaddd..ca8bf6154096 100644
--- a/include/media/media-fh.h
+++ b/include/media/media-fh.h
@@ -12,16 +12,21 @@
#include <linux/file.h>
#include <media/media-devnode.h>
+#include <media/media-evbase.h>
/**
* struct media_device_fh - File handle specific information on MC
*
* @fh: The media device file handle
* @mdev_list: This file handle in media device's list of file handles
+ * @ev_fh: File handle specific media event information
+ * @wait: File handle's wait queue
*/
struct media_device_fh {
struct media_devnode_fh fh;
struct list_head mdev_list;
+ struct media_evbase_fh ev_fh;
+ struct wait_queue_head wait;
};
static inline struct media_device_fh *media_device_fh(struct file *filp)
diff --git a/include/uapi/linux/media.h b/include/uapi/linux/media.h
index 2da6ae4da003..24b6b3f75592 100644
--- a/include/uapi/linux/media.h
+++ b/include/uapi/linux/media.h
@@ -373,6 +373,27 @@ struct media_v2_topology {
__u64 ptr_links;
} __attribute__ ((packed));
+#define MEDIA_EVENT_ALL 0
+
+struct media_event {
+ __u32 type;
+ union {
+ __u8 data[64];
+ } u;
+ __u32 reserved[8];
+ __u32 pending;
+ __u32 sequence;
+ __u64 timestamp;
+ __u32 id;
+} __attribute__((packed));
+
+struct media_event_subscription {
+ __u32 type;
+ __u32 id;
+ __u32 flags;
+ __u32 reserved[5];
+} __attribute__((packed));
+
/* ioctls */
#define MEDIA_IOC_DEVICE_INFO _IOWR('|', 0x00, struct media_device_info)
@@ -381,6 +402,9 @@ struct media_v2_topology {
#define MEDIA_IOC_SETUP_LINK _IOWR('|', 0x03, struct media_link_desc)
#define MEDIA_IOC_G_TOPOLOGY _IOWR('|', 0x04, struct media_v2_topology)
#define MEDIA_IOC_REQUEST_ALLOC _IOR ('|', 0x05, int)
+#define MEDIA_IOC_SUBSCRIBE_EVENT _IOWR ('|', 0x06, struct media_event_subscription)
+#define MEDIA_IOC_UNSUBSCRIBE_EVENT _IOWR ('|', 0x07, struct media_event_subscription)
+#define MEDIA_IOC_DQEVENT _IOWR('|', 0x08, struct media_event)
/*
* These ioctls are called on the request file descriptor as returned
--
2.56.0
next prev parent reply other threads:[~2026-11-18 12:44 UTC|newest]
Thread overview: 17+ messages / expand[flat|nested] mbox.gz Atom feed top
2026-11-18 12:43 [PATCH RFC v2 00/16] media: Fault-Tolerant V4L2 Mattijs Korpershoek
2026-11-18 12:43 ` [PATCH RFC v2 01/16] media: mc: Add struct media_device_fh pointer to media device IOCTL op Mattijs Korpershoek
2026-11-18 12:43 ` [PATCH RFC v2 02/16] media: mc: Add per-file-handle data support Mattijs Korpershoek
2026-11-18 12:43 ` [PATCH RFC v2 03/16] v4l: event: Separate event related information from struct v4l2_fh Mattijs Korpershoek
2026-11-18 12:43 ` [PATCH RFC v2 04/16] v4l: event: Rework data structures for separating events and V4L2 Mattijs Korpershoek
2026-11-18 12:43 ` [PATCH RFC v2 05/16] v4l: event: Split the event framework into generic and V4L2 bits Mattijs Korpershoek
2026-11-18 12:43 ` [PATCH RFC v2 06/16] media: mc: Maintain a list of open file handles in a media device Mattijs Korpershoek
2026-11-18 12:43 ` Mattijs Korpershoek [this message]
2026-11-18 12:43 ` [PATCH RFC v2 08/16] media: mc: Add MEDIA_EVENT_ENTITY_REGISTRATION Mattijs Korpershoek
2026-11-18 12:43 ` [PATCH RFC v2 09/16] Documentation: media: Add Media controller event documentation Mattijs Korpershoek
2026-11-18 12:43 ` [PATCH RFC v2 10/16] media: media.h: Add entity connection status Mattijs Korpershoek
2026-11-18 12:43 ` [PATCH RFC v2 11/16] media: mc: Add .detect() to media_entity_operations Mattijs Korpershoek
2026-11-18 12:43 ` [PATCH RFC v2 12/16] media: mc: Add MEDIA_IOC_G_ENTITY_STATUS ioctl Mattijs Korpershoek
2026-11-18 12:43 ` [PATCH RFC v2 13/16] media: mc: Add MEDIA_EVENT_ENTITY_STATUS_CHANGE event Mattijs Korpershoek
2026-11-18 12:43 ` [PATCH RFC v2 14/16] media: mc: Add detect polling helpers for drivers Mattijs Korpershoek
2026-11-18 12:43 ` [PATCH RFC v2 15/16] media: imx219: Allow driver probe with missing sensor Mattijs Korpershoek
2026-11-18 12:44 ` [PATCH RFC v2 16/16] media: imx219: Implement .detect() sensor operation Mattijs Korpershoek
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=20261118-v4l2-sensor-detect-v2-7-1bb1a445b556@kernel.org \
--to=mkorpershoek@kernel.org \
--cc=awalls@md.metrocast.net \
--cc=dave.stevenson@raspberrypi.com \
--cc=gustavoars@kernel.org \
--cc=hansg@kernel.org \
--cc=hverkuil+cisco@kernel.org \
--cc=kees@kernel.org \
--cc=kieran.bingham@ideasonboard.com \
--cc=laurent.pinchart@ideasonboard.com \
--cc=linux-hardening@vger.kernel.org \
--cc=linux-kernel@vger.kernel.org \
--cc=linux-media@vger.kernel.org \
--cc=mchehab@kernel.org \
--cc=michael.riesch@collabora.com \
--cc=mripard@kernel.org \
--cc=nicolas.dufres@collabora.com \
--cc=sakari.ailus@linux.intel.com \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox
all inboxes | Powered by JetHome®