media: subdev: Improve stream enable/disable machinery
v6 cover media: subdev: Improve stream enable/disable machinery
This series works on the .s_stream, .enable_streams, .disable_streams related code. The main feature introduced here, in the last two patchs, is adding support for .enable/disable_streams() for subdevs that do not implement full streams support.
Additionally we add support for the privacy led when v4l2_subdev_enable/disable_streams() is used.
I have tested this on RPi5.
Tomi
---
Changes in v6:
- v4l2_subdev_enable_streams() and v4l2_subdev_disable_streams()
accidentally returned -EINVAL when a stream was already
enabled/disabled. Change it back to -EALREADY.
- Add TODO note about privacy leds to "media: subdev: Support
single-stream case in v4l2_subdev_enable/disable_streams()"
- New commit "media: subdev: Improve s_stream documentation"
- Link to v5: https://lore.kernel.org/r/[email protected]
Changes in v5:
- Fix issues with non-routing case:
- Always set 'found_streams' variable instead of leaving it
uninitialized in "Support single-stream case in v4l2_subdev_enable/disable_streams()"
- Fix the "implicit" stream from bit 1 to bit 0 in "Support
non-routing subdevs in v4l2_subdev_s_stream_helper()"
- Link to v4: https://lore.kernel.org/r/[email protected]
Changes in v4:
- Added Rb tags
- Rename 'streaming_enabled' to 's_stream_enabled'
- Cosmetic changes (comments / patch descs)
- Added new patch "media: subdev: Support non-routing subdevs in v4l2_subdev_s_stream_helper()".
- Link to v3: https://lore.kernel.org/r/[email protected]
Changes in v3:
- Rebased on top of "[PATCH v2 1/1] media: v4l: Don't turn on privacy LED if streamon fails"
- Drop extra "!!" in "media: subdev: Fix use of sd->enabled_streams in call_s_stream()"
- Enable privacy LED after a succesfull stream enable in "media: subdev: Support privacy led in v4l2_subdev_enable/disable_streams()"
- Init 'cfg' variable when declaring in "media: subdev: Refactor v4l2_subdev_enable/disable_streams()"
- Link to v2: https://lore.kernel.org/r/[email protected]
Changes in v2:
- New patches for privacy led
- Use v4l2_subdev_has_op()
- Use BITS_PER_BYTE instead of 8
- Fix 80+ line issues
- Fix typos
- Check for pad < 64 also in the non-routing .enable/disable_streams code path
- Dropped "media: subdev: Support enable/disable_streams for non-streams
subdevs", which is implemented in a different way in new patches in this series
- Link to v1: https://lore.kernel.org/r/[email protected]
---
Tomi Valkeinen (11):
media: subdev: Add privacy led helpers
media: subdev: Use v4l2_subdev_has_op() in v4l2_subdev_enable/disable_streams()
media: subdev: Add checks for subdev features
media: subdev: Fix use of sd->enabled_streams in call_s_stream()
media: subdev: Improve v4l2_subdev_enable/disable_streams_fallback
media: subdev: Add v4l2_subdev_is_streaming()
media: subdev: Support privacy led in v4l2_subdev_enable/disable_streams()
media: subdev: Refactor v4l2_subdev_enable/disable_streams()
media: subdev: Support single-stream case in v4l2_subdev_enable/disable_streams()
media: subdev: Support non-routing subdevs in v4l2_subdev_s_stream_helper()
media: subdev: Improve s_stream documentation
drivers/media/v4l2-core/v4l2-subdev.c | 385 ++++++++++++++++++++-------------- include/media/v4l2-subdev.h | 34 ++- 2 files changed, 261 insertions(+), 158 deletions(-)
---
base-commit: e42a204f0519a2540f1507ac2798be2aeaa76bee
change-id: 20240404-enable-streams-impro-db8bcd898471
Best regards,
Signature · 1 line
Tomi Valkeinen <[email protected]>
PATCH v6 1/11 media: subdev: Add privacy led helpers
Add helper functions to enable and disable the privacy led. This moves the #if from the call site to the privacy led functions, and makes adding privacy led support to v4l2_subdev_enable/disable_streams() cleaner.
--- drivers/media/v4l2-core/v4l2-subdev.c | 30 +++++++++++++++++++++--------- 1 file changed, 21 insertions(+), 9 deletions(-)
drivers/media/v4l2-core/v4l2-subdev.c +21 -9
@@ -148,6 +148,23 @@ static int subdev_close(struct file *file) }#endif /* CONFIG_VIDEO_V4L2_SUBDEV_API */ +static void v4l2_subdev_enable_privacy_led (struct v4l2_subdev *sd) +{ +#if IS_REACHABLE (CONFIG_LEDS_CLASS ) +if (!IS_ERR_OR_NULL (sd->privacy_led)) +led_set_brightness (sd->privacy_led, + sd->privacy_led->max_brightness); +#endif +} + +static void v4l2_subdev_disable_privacy_led (struct v4l2_subdev *sd) +{ +#if IS_REACHABLE (CONFIG_LEDS_CLASS ) +if (!IS_ERR_OR_NULL (sd->privacy_led)) +led_set_brightness (sd->privacy_led,0 ); +#endif +} +static inline int check_which (u32 which) { if (which != V4L2_SUBDEV_FORMAT_TRY &&
@@ -452,15 +469,10 @@ static int call_s_stream(struct v4l2_subdev *sd, int enable)if (!ret) { sd->enabled_streams = enable ?BIT (0 ) :0 ; -#if IS_REACHABLE (CONFIG_LEDS_CLASS ) -if (!IS_ERR_OR_NULL (sd->privacy_led)) { -if (enable) -led_set_brightness (sd->privacy_led, - sd->privacy_led->max_brightness); -else -led_set_brightness (sd->privacy_led,0 ); - } -#endif +if (enable) +v4l2_subdev_enable_privacy_led (sd); +else +v4l2_subdev_disable_privacy_led (sd); }return ret;
Signature · 1 line
2.34.1
PATCH v6 2/11 media: subdev: Use v4l2_subdev_has_op() in v4l2_subdev_enable/disable_streams()
In reply to Tomi ValkeinenUse v4l2_subdev_has_op() in v4l2_subdev_enable/disable_streams() instead of open coding the same.
--- drivers/media/v4l2-core/v4l2-subdev.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)
drivers/media/v4l2-core/v4l2-subdev.c +2 -2
@@ -2168,7 +2168,7 @@ int v4l2_subdev_enable_streams(struct v4l2_subdev *sd, u32 pad,return 0 ;/* Fallback on .s_stream() if .enable_streams() isn't available. */ -if (!sd->ops->pad || !sd->ops->pad->enable_streams) +if (!v4l2_subdev_has_op (sd, pad, enable_streams))return v4l2_subdev_enable_streams_fallback (sd, pad, streams_mask);
@@ -2285,7 +2285,7 @@ int v4l2_subdev_disable_streams(struct v4l2_subdev *sd, u32 pad,return 0 ;/* Fallback on .s_stream() if .disable_streams() isn't available. */ -if (!sd->ops->pad || !sd->ops->pad->disable_streams) +if (!v4l2_subdev_has_op (sd, pad, disable_streams))return v4l2_subdev_disable_streams_fallback (sd, pad, streams_mask);
Signature · 1 line
2.34.1
PATCH v6 3/11 media: subdev: Add checks for subdev features
In reply to Tomi ValkeinenAdd some checks to verify that the subdev driver implements required features.
A subdevice that supports streams (V4L2_SUBDEV_FL_STREAMS) must do one of the following:
- Implement neither .enable/disable_streams() nor .s_stream(), if the subdev is part of a video driver that uses an internal method to enable the subdev.
- Implement only .enable/disable_streams(), if support for legacy sink-side subdevices is not needed.
- Implement .enable/disable_streams() and .s_stream(), if support for legacy sink-side subdevices is needed.
At the moment the framework doesn't check this requirement. Add the check.
--- drivers/media/v4l2-core/v4l2-subdev.c | 27 +++++++++++++++++++++++++++ 1 file changed, 27 insertions(+)
drivers/media/v4l2-core/v4l2-subdev.c +27 -0
@@ -1568,6 +1568,33 @@ int __v4l2_subdev_init_finalize(struct v4l2_subdev *sd, const char *name, struct lock_class_key *key) {struct v4l2_subdev_state *state; +struct device *dev = sd->dev; +bool has_disable_streams; +bool has_enable_streams; +bool has_s_stream; + +/* Check that the subdevice implements the required features */ + + has_s_stream =v4l2_subdev_has_op (sd, video, s_stream); + has_enable_streams =v4l2_subdev_has_op (sd, pad, enable_streams); + has_disable_streams =v4l2_subdev_has_op (sd, pad, disable_streams); + +if (has_enable_streams != has_disable_streams) { +dev_err (dev, +"subdev '%s' must implement both or neither of .enable_streams() and .disable_streams()\n" , + sd->name); +return -EINVAL ; + } + +if (sd->flags &V4L2_SUBDEV_FL_STREAMS ) { +if (has_s_stream && !has_enable_streams) { +dev_err (dev, +"subdev '%s' must implement .enable/disable_streams()\n" , + sd->name); + +return -EINVAL ; + } + } state =__v4l2_subdev_state_alloc (sd, name, key);if (IS_ERR (state))
Signature · 1 line
2.34.1
PATCH v6 4/11 media: subdev: Fix use of sd->enabled_streams in call_s_stream()
In reply to Tomi Valkeinencall_s_stream() uses sd->enabled_streams to track whether streaming has already been enabled. However, v4l2_subdev_enable/disable_streams_fallback(), which was the original user of this field, already uses it, and v4l2_subdev_enable/disable_streams_fallback() will call call_s_stream().
This leads to a conflict as both functions set the field. Afaics, both functions set the field to the same value, so it won't cause a runtime bug, but it's still wrong and if we, e.g., change how v4l2_subdev_enable/disable_streams_fallback() operates we might easily cause bugs.
Fix this by adding a new field, 's_stream_enabled', for call_s_stream().
--- drivers/media/v4l2-core/v4l2-subdev.c | 8 ++------ include/media/v4l2-subdev.h | 3 +++ 2 files changed, 5 insertions(+), 6 deletions(-)
drivers/media/v4l2-core/v4l2-subdev.c +2 -6
@@ -451,12 +451,8 @@ static int call_s_stream(struct v4l2_subdev *sd, int enable)* The .s_stream() operation must never be called to start or stop an * already started or stopped subdev. Catch offenders but don't return * an error yet to avoid regressions. -* -* As .s_stream() is mutually exclusive with the .enable_streams() and -* .disable_streams() operation, we can use the enabled_streams field -* to store the subdev streaming state. */ -if (WARN_ON (!!sd->enabled_streams == !!enable)) +if (WARN_ON (sd->s_stream_enabled == !!enable))return 0 ; ret = sd->ops->video->s_stream (sd, enable);
@@ -467,7 +463,7 @@ static int call_s_stream(struct v4l2_subdev *sd, int enable) }if (!ret) { - sd->enabled_streams = enable ?BIT (0 ) :0 ; + sd->s_stream_enabled = enable;if (enable)v4l2_subdev_enable_privacy_led (sd);
include/media/v4l2-subdev.h +3 -0
@@ -1043,6 +1043,8 @@ struct v4l2_subdev_platform_data {* v4l2_subdev_enable_streams() and * v4l2_subdev_disable_streams() helper functions for fallback * cases. +* @s_stream_enabled: Tracks whether streaming has been enabled with s_stream. +* This is only for call_s_stream() internal use. * * Each instance of a subdev driver should create this struct, either * stand-alone or embedded in a larger struct.
@@ -1091,6 +1093,7 @@ struct v4l2_subdev {*/ struct v4l2_subdev_state *active_state;u64 enabled_streams; +bool s_stream_enabled; };
Signature · 1 line
2.34.1
PATCH v6 5/11 media: subdev: Improve v4l2_subdev_enable/disable_streams_fallback
In reply to Tomi Valkeinenv4l2_subdev_enable/disable_streams_fallback() supports falling back to .s_stream() for subdevs with a single source pad. It also tracks the enabled streams for that one pad in the sd->enabled_streams field.
Tracking the enabled streams with sd->enabled_streams does not make sense, as with .s_stream() there can only be a single stream per pad. Thus, as the v4l2_subdev_enable/disable_streams_fallback() only supports a single source pad, all we really need is a boolean which tells whether streaming has been enabled on this pad or not.
However, as we only need a true/false state for a pad (instead of tracking which streams have been enabled for a pad), we can easily extend the fallback mechanism to support multiple source pads as we only need to keep track of which pads have been enabled.
Change the sd->enabled_streams field to sd->enabled_pads, which is a 64-bit bitmask tracking the enabled source pads. With this change we can remove the restriction that v4l2_subdev_enable/disable_streams_fallback() only supports a single source pad.
--- drivers/media/v4l2-core/v4l2-subdev.c | 68 ++++++++++++++++++++--------------- include/media/v4l2-subdev.h | 9 +++-- 2 files changed, 44 insertions(+), 33 deletions(-)
drivers/media/v4l2-core/v4l2-subdev.c +40 -28
@@ -2139,37 +2139,43 @@ static int v4l2_subdev_enable_streams_fallback(struct v4l2_subdev *sd, u32 pad, u64 streams_mask) {struct device *dev = sd->entity.graph_obj.mdev->dev; -unsigned int i;int ret;/* * The subdev doesn't implement pad-based stream enable, fall back -* on the .s_stream() operation. This can only be done for subdevs that -* have a single source pad, as sd->enabled_streams is global to the -* subdev. +* to the .s_stream() operation. */ if (!(sd->entity.pads[pad].flags &MEDIA_PAD_FL_SOURCE ))return -EOPNOTSUPP ; -for (i =0 ; i < sd->entity.num_pads; ++i) { -if (i != pad && sd->entity.pads[i].flags &MEDIA_PAD_FL_SOURCE ) -return -EOPNOTSUPP ; - } +/* +* .s_stream() means there is no streams support, so the only allowed +* stream is the implicit stream 0. +*/ +if (streams_mask !=BIT_ULL (0 )) +return -EOPNOTSUPP ; + +/* +* We use a 64-bit bitmask for tracking enabled pads, so only subdevices +* with 64 pads or less can be supported. +*/ +if (pad >=sizeof (sd->enabled_pads) *BITS_PER_BYTE ) +return -EOPNOTSUPP ; -if (sd->enabled_streams & streams_mask) { -dev_dbg (dev,"set of streams %#llx already enabled on %s:%u\n" , - streams_mask, sd->entity.name, pad); +if (sd->enabled_pads &BIT_ULL (pad)) { +dev_dbg (dev,"pad %u already enabled on %s\n" , + pad, sd->entity.name);return -EALREADY ; } -/* Start streaming when the first streams are enabled. */ -if (!sd->enabled_streams) { +/* Start streaming when the first pad is enabled. */ +if (!sd->enabled_pads) { ret =v4l2_subdev_call (sd, video, s_stream,1 );if (ret)return ret; } - sd->enabled_streams |= streams_mask; + sd->enabled_pads |=BIT_ULL (pad);return 0 ; }
@@ -2256,37 +2262,43 @@ static int v4l2_subdev_disable_streams_fallback(struct v4l2_subdev *sd, u32 pad, u64 streams_mask) {struct device *dev = sd->entity.graph_obj.mdev->dev; -unsigned int i;int ret;/* -* If the subdev doesn't implement pad-based stream enable, fall back -* on the .s_stream() operation. This can only be done for subdevs that -* have a single source pad, as sd->enabled_streams is global to the -* subdev. +* If the subdev doesn't implement pad-based stream enable, fall back +* to the .s_stream() operation. */ if (!(sd->entity.pads[pad].flags &MEDIA_PAD_FL_SOURCE ))return -EOPNOTSUPP ; -for (i =0 ; i < sd->entity.num_pads; ++i) { -if (i != pad && sd->entity.pads[i].flags &MEDIA_PAD_FL_SOURCE ) -return -EOPNOTSUPP ; - } +/* +* .s_stream() means there is no streams support, so the only allowed +* stream is the implicit stream 0. +*/ +if (streams_mask !=BIT_ULL (0 )) +return -EOPNOTSUPP ; + +/* +* We use a 64-bit bitmask for tracking enabled pads, so only subdevices +* with 64 pads or less can be supported. +*/ +if (pad >=sizeof (sd->enabled_pads) *BITS_PER_BYTE ) +return -EOPNOTSUPP ; -if ((sd->enabled_streams & streams_mask) != streams_mask) { -dev_dbg (dev,"set of streams %#llx already disabled on %s:%u\n" , - streams_mask, sd->entity.name, pad); +if (!(sd->enabled_pads &BIT_ULL (pad))) { +dev_dbg (dev,"pad %u already disabled on %s\n" , + pad, sd->entity.name);return -EALREADY ; }/* Stop streaming when the last streams are disabled. */ -if (!(sd->enabled_streams & ~streams_mask)) { +if (!(sd->enabled_pads & ~BIT_ULL (pad))) { ret =v4l2_subdev_call (sd, video, s_stream,0 );if (ret)return ret; } - sd->enabled_streams &= ~streams_mask; + sd->enabled_pads &= ~BIT_ULL (pad);return 0 ; }
include/media/v4l2-subdev.h +4 -5
@@ -1039,10 +1039,9 @@ struct v4l2_subdev_platform_data {* @active_state: Active state for the subdev (NULL for subdevs tracking the * state internally). Initialized by calling * v4l2_subdev_init_finalize(). -* @enabled_streams: Bitmask of enabled streams used by -* v4l2_subdev_enable_streams() and -* v4l2_subdev_disable_streams() helper functions for fallback -* cases. +* @enabled_pads: Bitmask of enabled pads used by v4l2_subdev_enable_streams() +* and v4l2_subdev_disable_streams() helper functions for +* fallback cases. * @s_stream_enabled: Tracks whether streaming has been enabled with s_stream. * This is only for call_s_stream() internal use. *
@@ -1092,7 +1091,7 @@ struct v4l2_subdev {* doesn't support it. */ struct v4l2_subdev_state *active_state; -u64 enabled_streams; +u64 enabled_pads;bool s_stream_enabled; };
Signature · 1 line
2.34.1
PATCH v6 6/11 media: subdev: Add v4l2_subdev_is_streaming()
In reply to Tomi ValkeinenAdd a helper function which returns whether the subdevice is streaming, i.e. if .s_stream or .enable_streams has been called successfully.
--- drivers/media/v4l2-core/v4l2-subdev.c | 25 +++++++++++++++++++++++++ include/media/v4l2-subdev.h | 13 +++++++++++++ 2 files changed, 38 insertions(+)
drivers/media/v4l2-core/v4l2-subdev.c +25 -0
@@ -2454,6 +2454,31 @@ void v4l2_subdev_notify_event(struct v4l2_subdev *sd, }EXPORT_SYMBOL_GPL (v4l2_subdev_notify_event); +bool v4l2_subdev_is_streaming (struct v4l2_subdev *sd) +{ +struct v4l2_subdev_state *state; + +if (!v4l2_subdev_has_op (sd, pad, enable_streams)) +return sd->s_stream_enabled; + +if (!(sd->flags &V4L2_SUBDEV_FL_STREAMS )) +return !!sd->enabled_pads; + + state =v4l2_subdev_get_locked_active_state (sd); + +for (unsigned int i =0 ; i < state->stream_configs.num_configs; ++i) { +const struct v4l2_subdev_stream_config *cfg; + + cfg = &state->stream_configs.configs[i]; + +if (cfg->enabled) +return true; + } + +return false; +} +EXPORT_SYMBOL_GPL (v4l2_subdev_is_streaming); +int v4l2_subdev_get_privacy_led (struct v4l2_subdev *sd) {#if IS_REACHABLE (CONFIG_LEDS_CLASS )
include/media/v4l2-subdev.h +13 -0
@@ -1914,4 +1914,17 @@ extern const struct v4l2_subdev_ops v4l2_subdev_call_wrappers;void v4l2_subdev_notify_event (struct v4l2_subdev *sd,const struct v4l2_event *ev); +/** +* v4l2_subdev_is_streaming() - Returns if the subdevice is streaming +* @sd: The subdevice +* +* v4l2_subdev_is_streaming() tells if the subdevice is currently streaming. +* "Streaming" here means whether .s_stream() or .enable_streams() has been +* successfully called, and the streaming has not yet been disabled. +* +* If the subdevice implements .enable_streams() this function must be called +* while holding the active state lock. +*/ +bool v4l2_subdev_is_streaming (struct v4l2_subdev *sd); +#endif /* _V4L2_SUBDEV_H */
Signature · 1 line
2.34.1
PATCH v6 7/11 media: subdev: Support privacy led in v4l2_subdev_enable/disable_streams()
In reply to Tomi ValkeinenWe support camera privacy leds with the .s_stream() operation, in call_s_stream(), but we don't have that support when the subdevice implements .enable/disable_streams() operations.
Add the support by enabling the led when the first stream for a subdevice is enabled, and disabling the led then the last stream is disabled.
--- drivers/media/v4l2-core/v4l2-subdev.c | 9 +++++++++ 1 file changed, 9 insertions(+)
drivers/media/v4l2-core/v4l2-subdev.c +9 -0
@@ -2185,6 +2185,7 @@ int v4l2_subdev_enable_streams(struct v4l2_subdev *sd, u32 pad, {struct device *dev = sd->entity.graph_obj.mdev->dev;struct v4l2_subdev_state *state; +bool already_streaming;u64 found_streams =0 ;unsigned int i;int ret;
@@ -2233,6 +2234,8 @@ int v4l2_subdev_enable_streams(struct v4l2_subdev *sd, u32 pad,dev_dbg (dev,"enable streams %u:%#llx\n" , pad, streams_mask); + already_streaming =v4l2_subdev_is_streaming (sd); +/* Call the .enable_streams() operation. */ ret =v4l2_subdev_call (sd, pad, enable_streams, state, pad, streams_mask);
@@ -2251,6 +2254,9 @@ int v4l2_subdev_enable_streams(struct v4l2_subdev *sd, u32 pad, cfg->enabled = true; } +if (!already_streaming) +v4l2_subdev_enable_privacy_led (sd); + done:v4l2_subdev_unlock_state (state);
@@ -2375,6 +2381,9 @@ int v4l2_subdev_disable_streams(struct v4l2_subdev *sd, u32 pad, } done: +if (!v4l2_subdev_is_streaming (sd)) +v4l2_subdev_disable_privacy_led (sd); +v4l2_subdev_unlock_state (state);return ret;
Signature · 1 line
2.34.1
PATCH v6 8/11 media: subdev: Refactor v4l2_subdev_enable/disable_streams()
In reply to Tomi ValkeinenAdd two internal helper functions, v4l2_subdev_collect_streams() and v4l2_subdev_set_streams_enabled(), which allows us to refactor v4l2_subdev_enable/disable_streams() functions.
This (I think) makes the code a bit easier to read, and lets us more easily add new functionality in the helper functions in the following patch.
--- drivers/media/v4l2-core/v4l2-subdev.c | 109 +++++++++++++++++++--------------- 1 file changed, 60 insertions(+), 49 deletions(-)
drivers/media/v4l2-core/v4l2-subdev.c +60 -49
@@ -2135,6 +2135,42 @@ int v4l2_subdev_routing_validate(struct v4l2_subdev *sd, }EXPORT_SYMBOL_GPL (v4l2_subdev_routing_validate); +static void v4l2_subdev_collect_streams (struct v4l2_subdev *sd, +struct v4l2_subdev_state *state, +u32 pad,u64 streams_mask, +u64 *found_streams, +u64 *enabled_streams) +{ + *found_streams =0 ; + *enabled_streams =0 ; + +for (unsigned int i =0 ; i < state->stream_configs.num_configs; ++i) { +const struct v4l2_subdev_stream_config *cfg = + &state->stream_configs.configs[i]; + +if (cfg->pad != pad || !(streams_mask &BIT_ULL (cfg->stream))) +continue ; + + *found_streams |=BIT_ULL (cfg->stream); +if (cfg->enabled) + *enabled_streams |=BIT_ULL (cfg->stream); + } +} + +static void v4l2_subdev_set_streams_enabled (struct v4l2_subdev *sd, +struct v4l2_subdev_state *state, +u32 pad,u64 streams_mask, +bool enabled) +{ +for (unsigned int i =0 ; i < state->stream_configs.num_configs; ++i) { +struct v4l2_subdev_stream_config *cfg = + &state->stream_configs.configs[i]; + +if (cfg->pad == pad && (streams_mask &BIT_ULL (cfg->stream))) + cfg->enabled = enabled; + } +} +static int v4l2_subdev_enable_streams_fallback (struct v4l2_subdev *sd,u32 pad,u64 streams_mask) {
@@ -2186,8 +2222,8 @@ int v4l2_subdev_enable_streams(struct v4l2_subdev *sd, u32 pad,struct device *dev = sd->entity.graph_obj.mdev->dev;struct v4l2_subdev_state *state;bool already_streaming; -u64 found_streams =0 ; -unsigned int i; +u64 enabled_streams; +u64 found_streams;int ret;/* A few basic sanity checks first. */
@@ -2208,22 +2244,9 @@ int v4l2_subdev_enable_streams(struct v4l2_subdev *sd, u32 pad,* Verify that the requested streams exist and that they are not * already enabled. */ -for (i =0 ; i < state->stream_configs.num_configs; ++i) { -struct v4l2_subdev_stream_config *cfg = - &state->stream_configs.configs[i]; -if (cfg->pad != pad || !(streams_mask &BIT_ULL (cfg->stream))) -continue ; - - found_streams |=BIT_ULL (cfg->stream); - -if (cfg->enabled) { -dev_dbg (dev,"stream %u already enabled on %s:%u\n" , - cfg->stream, sd->entity.name, pad); - ret = -EALREADY ; - goto done; - } - } +v4l2_subdev_collect_streams (sd, state, pad, streams_mask, + &found_streams, &enabled_streams);if (found_streams != streams_mask) { dev_dbg(dev, "streams 0x%llx not found on %s:%u\n",
@@ -2232,6 +2255,13 @@ int v4l2_subdev_enable_streams(struct v4l2_subdev *sd, u32 pad, goto done; } +if (enabled_streams) { +dev_dbg (dev,"streams 0x%llx already enabled on %s:%u\n" , + enabled_streams, sd->entity.name, pad); + ret = -EALREADY ; + goto done; + } +dev_dbg (dev,"enable streams %u:%#llx\n" , pad, streams_mask); already_streaming =v4l2_subdev_is_streaming (sd);
@@ -2246,13 +2276,7 @@ int v4l2_subdev_enable_streams(struct v4l2_subdev *sd, u32 pad, }/* Mark the streams as enabled. */ -for (i =0 ; i < state->stream_configs.num_configs; ++i) { -struct v4l2_subdev_stream_config *cfg = - &state->stream_configs.configs[i]; - -if (cfg->pad == pad && (streams_mask &BIT_ULL (cfg->stream))) - cfg->enabled = true; - } +v4l2_subdev_set_streams_enabled (sd, state, pad, streams_mask, true);if (!already_streaming)v4l2_subdev_enable_privacy_led (sd);
@@ -2314,8 +2338,8 @@ int v4l2_subdev_disable_streams(struct v4l2_subdev *sd, u32 pad, {struct device *dev = sd->entity.graph_obj.mdev->dev;struct v4l2_subdev_state *state; -u64 found_streams =0 ; -unsigned int i; +u64 enabled_streams; +u64 found_streams;int ret;/* A few basic sanity checks first. */
@@ -2336,22 +2360,9 @@ int v4l2_subdev_disable_streams(struct v4l2_subdev *sd, u32 pad,* Verify that the requested streams exist and that they are not * already disabled. */ -for (i =0 ; i < state->stream_configs.num_configs; ++i) { -struct v4l2_subdev_stream_config *cfg = - &state->stream_configs.configs[i]; -if (cfg->pad != pad || !(streams_mask &BIT_ULL (cfg->stream))) -continue ; - - found_streams |=BIT_ULL (cfg->stream); - -if (!cfg->enabled) { -dev_dbg (dev,"stream %u already disabled on %s:%u\n" , - cfg->stream, sd->entity.name, pad); - ret = -EALREADY ; - goto done; - } - } +v4l2_subdev_collect_streams (sd, state, pad, streams_mask, + &found_streams, &enabled_streams);if (found_streams != streams_mask) { dev_dbg(dev, "streams 0x%llx not found on %s:%u\n",
@@ -2360,6 +2371,13 @@ int v4l2_subdev_disable_streams(struct v4l2_subdev *sd, u32 pad, goto done; } +if (enabled_streams != streams_mask) { +dev_dbg (dev,"streams 0x%llx already disabled on %s:%u\n" , + streams_mask & ~enabled_streams, sd->entity.name, pad); + ret = -EALREADY ; + goto done; + } +dev_dbg (dev,"disable streams %u:%#llx\n" , pad, streams_mask);/* Call the .disable_streams() operation. */
@@ -2371,14 +2389,7 @@ int v4l2_subdev_disable_streams(struct v4l2_subdev *sd, u32 pad, goto done; } -/* Mark the streams as disabled. */ -for (i =0 ; i < state->stream_configs.num_configs; ++i) { -struct v4l2_subdev_stream_config *cfg = - &state->stream_configs.configs[i]; - -if (cfg->pad == pad && (streams_mask &BIT_ULL (cfg->stream))) - cfg->enabled = false; - } +v4l2_subdev_set_streams_enabled (sd, state, pad, streams_mask, false); done:if (!v4l2_subdev_is_streaming (sd))
Signature · 1 line
2.34.1
PATCH v6 9/11 media: subdev: Support single-stream case in v4l2_subdev_enable/disable_streams()
In reply to Tomi ValkeinenAt the moment the v4l2_subdev_enable/disable_streams() functions call fallback helpers to handle the case where the subdev only implements .s_stream(), and the main function handles the case where the subdev implements streams (V4L2_SUBDEV_FL_STREAMS, which implies .enable/disable_streams()).
What is missing is support for subdevs which do not implement streams support, but do implement .enable/disable_streams(). Example cases of these subdevices are single-stream cameras, where using .enable/disable_streams() is not required but helps us remove the users of the legacy .s_stream(), and subdevices with multiple source pads (but single stream per pad), where .enable/disable_streams() allows the subdevice to control the enable/disable state per pad.
The two single-streams cases (.s_stream() and .enable/disable_streams()) are very similar, and with small changes we can change the v4l2_subdev_enable/disable_streams() functions to support all three cases, without needing separate fallback functions.
A few potentially problematic details, though:
- For the single-streams cases we use sd->enabled_pads field, which limits the number of pads for the subdevice to 64. For simplicity I added the check for this limitation to the beginning of the function, and it also applies to the streams case.
- The fallback functions only allowed the target pad to be a source pad. It is not very clear to me why this check was needed, but it was not needed in the streams case. However, I doubt the v4l2_subdev_enable/disable_streams() code has ever been tested with sink pads, so to be on the safe side, I added the same check to the v4l2_subdev_enable/disable_streams() functions.
--- drivers/media/v4l2-core/v4l2-subdev.c | 194 +++++++++++++++------------------- 1 file changed, 86 insertions(+), 108 deletions(-)
drivers/media/v4l2-core/v4l2-subdev.c +86 -108
@@ -2141,6 +2141,13 @@ static void v4l2_subdev_collect_streams(struct v4l2_subdev *sd, u64 *found_streams, u64 *enabled_streams) { +if (!(sd->flags &V4L2_SUBDEV_FL_STREAMS )) { + *found_streams =BIT_ULL (0 ); + *enabled_streams = + (sd->enabled_pads &BIT_ULL (pad)) ?BIT_ULL (0 ) :0 ; +return ; + } + *found_streams =0 ; *enabled_streams =0 ;
@@ -2162,6 +2169,14 @@ static void v4l2_subdev_set_streams_enabled(struct v4l2_subdev *sd, u32 pad, u64 streams_mask, bool enabled) { + if (!(sd->flags & V4L2_SUBDEV_FL_STREAMS)) { + if (enabled) + sd->enabled_pads |= BIT_ULL(pad); + else + sd->enabled_pads &= ~BIT_ULL(pad); +return ; + } +for (unsigned int i =0 ; i < state->stream_configs.num_configs; ++i) {struct v4l2_subdev_stream_config *cfg = &state->stream_configs.configs[i];
@@ -2171,51 +2186,6 @@ static void v4l2_subdev_set_streams_enabled(struct v4l2_subdev *sd, } } -static int v4l2_subdev_enable_streams_fallback (struct v4l2_subdev *sd,u32 pad, -u64 streams_mask) -{ -struct device *dev = sd->entity.graph_obj.mdev->dev; -int ret; - -/* -* The subdev doesn't implement pad-based stream enable, fall back -* to the .s_stream() operation. -*/ -if (!(sd->entity.pads[pad].flags &MEDIA_PAD_FL_SOURCE )) -return -EOPNOTSUPP ; - -/* -* .s_stream() means there is no streams support, so the only allowed -* stream is the implicit stream 0. -*/ -if (streams_mask !=BIT_ULL (0 )) -return -EOPNOTSUPP ; - -/* -* We use a 64-bit bitmask for tracking enabled pads, so only subdevices -* with 64 pads or less can be supported. -*/ -if (pad >=sizeof (sd->enabled_pads) *BITS_PER_BYTE ) -return -EOPNOTSUPP ; - -if (sd->enabled_pads &BIT_ULL (pad)) { -dev_dbg (dev,"pad %u already enabled on %s\n" , - pad, sd->entity.name); -return -EALREADY ; - } - -/* Start streaming when the first pad is enabled. */ -if (!sd->enabled_pads) { - ret =v4l2_subdev_call (sd, video, s_stream,1 ); -if (ret) -return ret; - } - - sd->enabled_pads |=BIT_ULL (pad); - -return 0 ; -} -int v4l2_subdev_enable_streams (struct v4l2_subdev *sd,u32 pad,u64 streams_mask) {
@@ -2224,21 +2194,33 @@ int v4l2_subdev_enable_streams(struct v4l2_subdev *sd, u32 pad,bool already_streaming;u64 enabled_streams;u64 found_streams; +bool use_s_stream;int ret;/* A few basic sanity checks first. */ if (pad >= sd->entity.num_pads)return -EINVAL ; +if (!(sd->entity.pads[pad].flags &MEDIA_PAD_FL_SOURCE )) +return -EOPNOTSUPP ; + +/* +* We use a 64-bit bitmask for tracking enabled pads, so only subdevices +* with 64 pads or less can be supported. +*/ +if (pad >=sizeof (sd->enabled_pads) *BITS_PER_BYTE ) +return -EOPNOTSUPP ; +if (!streams_mask)return 0 ;/* Fallback on .s_stream() if .enable_streams() isn't available. */ -if (!v4l2_subdev_has_op (sd, pad, enable_streams)) -return v4l2_subdev_enable_streams_fallback (sd, pad, - streams_mask); + use_s_stream = !v4l2_subdev_has_op (sd, pad, enable_streams); - state =v4l2_subdev_lock_and_get_active_state (sd); +if (!use_s_stream) + state =v4l2_subdev_lock_and_get_active_state (sd); +else + state =NULL ;/* * Verify that the requested streams exist and that they are not
@@ -2266,9 +2248,18 @@ int v4l2_subdev_enable_streams(struct v4l2_subdev *sd, u32 pad, already_streaming =v4l2_subdev_is_streaming (sd); -/* Call the .enable_streams() operation. */ - ret =v4l2_subdev_call (sd, pad, enable_streams, state, pad, - streams_mask); +if (!use_s_stream) { +/* Call the .enable_streams() operation. */ + ret =v4l2_subdev_call (sd, pad, enable_streams, state, pad, + streams_mask); + }else { +/* Start streaming when the first pad is enabled. */ +if (!already_streaming) + ret =v4l2_subdev_call (sd, video, s_stream,1 ); +else + ret =0 ; + } +if (ret) {dev_dbg (dev,"enable streams %u:%#llx failed: %d\n" , pad, streams_mask, ret);
@@ -2278,34 +2269,39 @@ int v4l2_subdev_enable_streams(struct v4l2_subdev *sd, u32 pad,/* Mark the streams as enabled. */ v4l2_subdev_set_streams_enabled (sd, state, pad, streams_mask, true); -if (!already_streaming) +/* +* TODO: When all the drivers have been changed to use +* v4l2_subdev_enable_streams() and v4l2_subdev_disable_streams(), +* instead of calling .s_stream() operation directly, we can remove +* the privacy LED handling from call_s_stream() and do it here +* for all cases. +*/ +if (!use_s_stream && !already_streaming)v4l2_subdev_enable_privacy_led (sd); done: -v4l2_subdev_unlock_state (state); +if (!use_s_stream) +v4l2_subdev_unlock_state (state);return ret; }EXPORT_SYMBOL_GPL (v4l2_subdev_enable_streams); -static int v4l2_subdev_disable_streams_fallback (struct v4l2_subdev *sd,u32 pad, -u64 streams_mask) +int v4l2_subdev_disable_streams (struct v4l2_subdev *sd,u32 pad, +u64 streams_mask) {struct device *dev = sd->entity.graph_obj.mdev->dev; +struct v4l2_subdev_state *state; +u64 enabled_streams; +u64 found_streams; +bool use_s_stream;int ret; -/* -* If the subdev doesn't implement pad-based stream enable, fall back -* to the .s_stream() operation. -*/ -if (!(sd->entity.pads[pad].flags &MEDIA_PAD_FL_SOURCE )) -return -EOPNOTSUPP ; +/* A few basic sanity checks first. */ +if (pad >= sd->entity.num_pads) +return -EINVAL ; -/* -* .s_stream() means there is no streams support, so the only allowed -* stream is the implicit stream 0. -*/ -if (streams_mask !=BIT_ULL (0 )) +if (!(sd->entity.pads[pad].flags &MEDIA_PAD_FL_SOURCE ))return -EOPNOTSUPP ;/*
@@ -2315,46 +2311,16 @@ static int v4l2_subdev_disable_streams_fallback(struct v4l2_subdev *sd, u32 pad,if (pad >=sizeof (sd->enabled_pads) *BITS_PER_BYTE )return -EOPNOTSUPP ; -if (!(sd->enabled_pads &BIT_ULL (pad))) { -dev_dbg (dev,"pad %u already disabled on %s\n" , - pad, sd->entity.name); -return -EALREADY ; - } - -/* Stop streaming when the last streams are disabled. */ -if (!(sd->enabled_pads & ~BIT_ULL (pad))) { - ret =v4l2_subdev_call (sd, video, s_stream,0 ); -if (ret) -return ret; - } - - sd->enabled_pads &= ~BIT_ULL (pad); - -return 0 ; -} - -int v4l2_subdev_disable_streams (struct v4l2_subdev *sd,u32 pad, -u64 streams_mask) -{ -struct device *dev = sd->entity.graph_obj.mdev->dev; -struct v4l2_subdev_state *state; -u64 enabled_streams; -u64 found_streams; -int ret; - -/* A few basic sanity checks first. */ -if (pad >= sd->entity.num_pads) -return -EINVAL ; -if (!streams_mask)return 0 ;/* Fallback on .s_stream() if .disable_streams() isn't available. */ -if (!v4l2_subdev_has_op (sd, pad, disable_streams)) -return v4l2_subdev_disable_streams_fallback (sd, pad, - streams_mask); + use_s_stream = !v4l2_subdev_has_op (sd, pad, disable_streams); - state =v4l2_subdev_lock_and_get_active_state (sd); +if (!use_s_stream) + state =v4l2_subdev_lock_and_get_active_state (sd); +else + state =NULL ;/* * Verify that the requested streams exist and that they are not
@@ -2380,9 +2346,19 @@ int v4l2_subdev_disable_streams(struct v4l2_subdev *sd, u32 pad,dev_dbg (dev,"disable streams %u:%#llx\n" , pad, streams_mask); -/* Call the .disable_streams() operation. */ - ret =v4l2_subdev_call (sd, pad, disable_streams, state, pad, - streams_mask); +if (!use_s_stream) { +/* Call the .disable_streams() operation. */ + ret =v4l2_subdev_call (sd, pad, disable_streams, state, pad, + streams_mask); + }else { +/* Stop streaming when the last streams are disabled. */ + +if (!(sd->enabled_pads & ~BIT_ULL (pad))) + ret =v4l2_subdev_call (sd, video, s_stream,0 ); +else + ret =0 ; + } +if (ret) {dev_dbg (dev,"disable streams %u:%#llx failed: %d\n" , pad, streams_mask, ret);
@@ -2392,10 +2368,12 @@ int v4l2_subdev_disable_streams(struct v4l2_subdev *sd, u32 pad,v4l2_subdev_set_streams_enabled (sd, state, pad, streams_mask, false); done: -if (!v4l2_subdev_is_streaming (sd)) -v4l2_subdev_disable_privacy_led (sd); +if (!use_s_stream) { +if (!v4l2_subdev_is_streaming (sd)) +v4l2_subdev_disable_privacy_led (sd); -v4l2_subdev_unlock_state (state); +v4l2_subdev_unlock_state (state); + }return ret; }
Signature · 1 line
2.34.1
PATCH v6 10/11 media: subdev: Support non-routing subdevs in v4l2_subdev_s_stream_helper()
In reply to Tomi ValkeinenAt the moment v4l2_subdev_s_stream_helper() only works for subdevices that support routing. As enable/disable_streams now also works for subdevices without routing, improve v4l2_subdev_s_stream_helper() to do the same.
--- drivers/media/v4l2-core/v4l2-subdev.c | 23 ++++++++++++++++------- 1 file changed, 16 insertions(+), 7 deletions(-)
drivers/media/v4l2-core/v4l2-subdev.c +16 -7
@@ -2402,15 +2402,24 @@ int v4l2_subdev_s_stream_helper(struct v4l2_subdev *sd, int enable)if (WARN_ON (pad_index ==-1 ))return -EINVAL ; -/* -* As there's a single source pad, just collect all the source streams. -*/ - state =v4l2_subdev_lock_and_get_active_state (sd); +if (sd->flags &V4L2_SUBDEV_FL_STREAMS ) { +/* +* As there's a single source pad, just collect all the source +* streams. +*/ + state =v4l2_subdev_lock_and_get_active_state (sd); -for_each_active_route (&state->routing, route) - source_mask |=BIT_ULL (route->source_stream); +for_each_active_route (&state->routing, route) + source_mask |=BIT_ULL (route->source_stream); -v4l2_subdev_unlock_state (state); +v4l2_subdev_unlock_state (state); + }else { +/* +* For non-streams subdevices, there's a single implicit stream +* per pad. +*/ + source_mask =BIT_ULL (0 ); + }if (enable)return v4l2_subdev_enable_streams (sd, pad_index, source_mask);
Signature · 1 line
2.34.1
PATCH v6 11/11 media: subdev: Improve s_stream documentation
In reply to Tomi ValkeinenNow that enable/disable_streams operations are available for single-stream subdevices too, there's no reason to use the old s_stream operation on new drivers. Extend the documentation reflecting this.
--- include/media/v4l2-subdev.h | 9 +++++++++ 1 file changed, 9 insertions(+)
include/media/v4l2-subdev.h +9 -0
@@ -450,6 +450,15 @@ enum v4l2_subdev_pre_streamon_flags {* already started or stopped subdev. Also see call_s_stream wrapper in * v4l2-subdev.c. * +* New drivers should instead implement &v4l2_subdev_pad_ops.enable_streams +* and &v4l2_subdev_pad_ops.disable_streams operations, and use +* v4l2_subdev_s_stream_helper for the &v4l2_subdev_video_ops.s_stream +* operation to support legacy users. +* +* Drivers should also not call the .s_stream() subdev operation directly, +* but use the v4l2_subdev_enable_streams() and +* v4l2_subdev_disable_streams() helpers. +* * @g_pixelaspect: callback to return the pixelaspect ratio. * * @s_rx_buffer: set a host allocated memory buffer for the subdev. The subdev
Signature · 1 line
2.34.1
Re: [PATCH v6 11/11] media: subdev: Improve s_stream documentation
Hi Tomi,
Quoted 5 lines · Tomi Valkeinen
Now that enable/disable_streams operations are available for single-stream subdevices too, there's no reason to use the old
s_streamoperation on new drivers. Extend the documentation reflecting this.Signed-off-by Tomi Valkeinen <[email protected]>
Quoted 25 lines
--- include/media/v4l2-subdev.h | 9 +++++++++ 1 file changed, 9 insertions(+)include/media/v4l2-subdev.h +9
-0@@ -450,6 +450,15 @@ enum v4l2_subdev_pre_streamon_flags {* already started or stopped subdev. Also see call_s_stream wrapper in * v4l2-subdev.c. * +* New drivers should instead implement &v4l2_subdev_pad_ops.enable_streams +* and &v4l2_subdev_pad_ops.disable_streams operations, and use +* v4l2_subdev_s_stream_helper for the &v4l2_subdev_video_ops.s_stream +* operation to support legacy users. +* +* Drivers should also not call the .s_stream() subdev operation directly, +* but use the v4l2_subdev_enable_streams() and +* v4l2_subdev_disable_streams() helpers. +* * @g_pixelaspect: callback to return the pixelaspect ratio. * * @s_rx_buffer: set a host allocated memory buffer for the subdev. The subdev
Re: [PATCH v6 11/11] media: subdev: Improve s_stream documentation
In reply to Tomi ValkeinenHi Tomi,
Thank you for the patch.
Quoted 5 lines · Tomi Valkeinen
Now that enable/disable_streams operations are available for single-stream subdevices too, there's no reason to use the old
s_streamoperation on new drivers. Extend the documentation reflecting this.Signed-off-by Tomi Valkeinen <[email protected]>
Quoted 24 lines
--- include/media/v4l2-subdev.h | 9 +++++++++ 1 file changed, 9 insertions(+)include/media/v4l2-subdev.h +9
-0@@ -450,6 +450,15 @@ enum v4l2_subdev_pre_streamon_flags {* already started or stopped subdev. Also see call_s_stream wrapper in * v4l2-subdev.c. * +* New drivers should instead implement &v4l2_subdev_pad_ops.enable_streams +* and &v4l2_subdev_pad_ops.disable_streams operations, and use +* v4l2_subdev_s_stream_helper for the &v4l2_subdev_video_ops.s_stream +* operation to support legacy users. +* +* Drivers should also not call the .s_stream() subdev operation directly, +* but use the v4l2_subdev_enable_streams() and +* v4l2_subdev_disable_streams() helpers. +* * @g_pixelaspect: callback to return the pixelaspect ratio. * * @s_rx_buffer: set a host allocated memory buffer for the subdev. The subdev
Signature · 3 lines
Regards, Laurent Pinchart
Re: [PATCH v6 11/11] media: subdev: Improve s_stream documentation
Hi Laurent, others,
Quoted 4 lines · Laurent Pinchart
Hi Tomi,
Thank you for the patch.
Quoted 8 lines
Quoted 5 lines · Tomi Valkeinen
Now that enable/disable_streams operations are available for single-stream subdevices too, there's no reason to use the old
s_streamoperation on new drivers. Extend the documentation reflecting this.Signed-off-by Tomi Valkeinen <[email protected]>Reviewed-by Laurent Pinchart <[email protected]>
Thanks!
If there are no further comments requiring changes, I'll send a PR on these with Umang's imx335 and my CCS driver patches tomorrow.
Signature · 3 lines
Kind regards, Sakari Ailus