From patchwork Fri Apr 5 09:14:19 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Tomi Valkeinen X-Patchwork-Id: 786646 Received: from perceval.ideasonboard.com (perceval.ideasonboard.com [213.167.242.64]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id D6BC415FA6C; Fri, 5 Apr 2024 09:14:43 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=213.167.242.64 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1712308485; cv=none; b=HcbggogfLxngUb7XfA16uUcX/1XRXC2DbZGMpzmxhSvzVoONNaMdeTGGcwQkyvc6GPYN95bS+WHb40YEma6FYQ1lKL5+1nTM+9GHQps2xnjqFPopzmM7VF5T5bLTL51Zgd8lmOz/S+ULUmt8YVXSTWao6DjG+8pQi/TTiyKZ39M= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1712308485; c=relaxed/simple; bh=9mXTtGDpitUEzyHWLPsdvBFtHi7vvqqQxqsj2Nz0lu4=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=FeNkK2n/avCy2Gq3G5uenaASe6mNeSpsv/ZzlMfaDZ3lVtbkhLWTrl8r6JKgL8fQnUR6y0em8mhREdlDTSUlRHfdZYzvNZGEzOLhZRCq3n9oWIjzyRKrTJymlQGdPU9CSmY8xKk63PePqTmue92GOzDleB7xTNROG2NtfJqQs4o= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=none (p=none dis=none) header.from=ideasonboard.com; spf=pass smtp.mailfrom=ideasonboard.com; dkim=pass (1024-bit key) header.d=ideasonboard.com header.i=@ideasonboard.com header.b=W5bHRzKr; arc=none smtp.client-ip=213.167.242.64 Authentication-Results: smtp.subspace.kernel.org; dmarc=none (p=none dis=none) header.from=ideasonboard.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=ideasonboard.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (1024-bit key) header.d=ideasonboard.com header.i=@ideasonboard.com header.b="W5bHRzKr" Received: from [127.0.1.1] (91-154-34-181.elisa-laajakaista.fi [91.154.34.181]) by perceval.ideasonboard.com (Postfix) with ESMTPSA id B518DDC9; Fri, 5 Apr 2024 11:14:02 +0200 (CEST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=ideasonboard.com; s=mail; t=1712308443; bh=9mXTtGDpitUEzyHWLPsdvBFtHi7vvqqQxqsj2Nz0lu4=; h=From:Date:Subject:References:In-Reply-To:To:Cc:From; b=W5bHRzKrFAvISyg13zUuyoz3wwwRzSHotxpZTD0jIdZ2bPJM/2b8/8bPj7MS0unf7 6HCsWefCjzYz3rhM9F3CV3pK00d9QKwDk8ogDS2YKfFXrU7FBI7rFcRxmAuHLiXYjy FYYVgrU5q5Yc14D2rG+H4pZodObfYIhPCEKiwqLI= From: Tomi Valkeinen Date: Fri, 05 Apr 2024 12:14:19 +0300 Subject: [PATCH v2 1/9] media: subdev: Add privacy led helpers Precedence: bulk X-Mailing-List: linux-media@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Message-Id: <20240405-enable-streams-impro-v2-1-22bca967665d@ideasonboard.com> References: <20240405-enable-streams-impro-v2-0-22bca967665d@ideasonboard.com> In-Reply-To: <20240405-enable-streams-impro-v2-0-22bca967665d@ideasonboard.com> To: Mauro Carvalho Chehab , Hans Verkuil , Laurent Pinchart , Sakari Ailus , Umang Jain Cc: linux-media@vger.kernel.org, linux-kernel@vger.kernel.org, Tomi Valkeinen X-Mailer: b4 0.13.0 X-Developer-Signature: v=1; a=openpgp-sha256; l=1915; i=tomi.valkeinen@ideasonboard.com; h=from:subject:message-id; bh=9mXTtGDpitUEzyHWLPsdvBFtHi7vvqqQxqsj2Nz0lu4=; b=owEBbQKS/ZANAwAIAfo9qoy8lh71AcsmYgBmD8D9PKk5m/aneVv3WUawS0bT8nWPrkksElujb rmAHCaFW7yJAjMEAAEIAB0WIQTEOAw+ll79gQef86f6PaqMvJYe9QUCZg/A/QAKCRD6PaqMvJYe 9RLAEACYtjUDlFJ7FR4epbNukPUUDe68AtpfG1hqKIi6H5qlJTgNRiRaR0nVqM6dXNKgrOYpU/4 oz7tD7t3hATzqAUKTSb0V7/fkfx47rlOk4OZuipqNZk06NHgyFXQeObzMQpWxQBu/sEHqZMrrjk 5GMwgskmvW+4UH7FnDDrwG0FepOxsfktooZ4Hfgf95OeLoD7tDkAQWIjPdaMwbvHwPxOhZTRd6n nSSqZFY0SkyZhGH5azenbA9HO0+cU0a14h2SZbLyJkRhDYstY+Iehe4BJzkLl+fm1MMyx1eRihw qlhwlIf28PHbKBOPXsMRcSv+br4wgU6qKa3RP+FHajNoJhf+kIv5O7nRkNBRb3mZz/tGRJFHNBH j22cSjmnhor786XrSvtTOmQxdGF37jhCNfyiqwe9tNhdfvb9n8LVQSsuUdr52kNdyc64NzVsWtF Rmm/yRnz77cLO4wVnoLSlyW05ciEdQ+ATlkCaFExtavbnzz0LqJC6HvrdIHufr5pSHORDMxnq/e xuz8puyQpCcrYS+GrTg7znad/qojZyE8bvv2BSkpOJiyNk9tb4Qla5SnDuzuN0tQZr6OQyUNAUR q+y7c1qnJ9/YFF60gjRjFCk4mVnZ813WL8HzaqBJHNd4EoAME4NJ+51D4J0kwO14gFRRKoBYiQl DHIwP4pyHxt89XQ== X-Developer-Key: i=tomi.valkeinen@ideasonboard.com; a=openpgp; fpr=C4380C3E965EFD81079FF3A7FA3DAA8CBC961EF5 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. Signed-off-by: Tomi Valkeinen --- drivers/media/v4l2-core/v4l2-subdev.c | 31 ++++++++++++++++++++++--------- 1 file changed, 22 insertions(+), 9 deletions(-) diff --git a/drivers/media/v4l2-core/v4l2-subdev.c b/drivers/media/v4l2-core/v4l2-subdev.c index 4c6198c48dd6..942c7a644033 100644 --- a/drivers/media/v4l2-core/v4l2-subdev.c +++ b/drivers/media/v4l2-core/v4l2-subdev.c @@ -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 && @@ -412,15 +429,11 @@ static int call_s_stream(struct v4l2_subdev *sd, int enable) if (WARN_ON(!!sd->enabled_streams == !!enable)) return 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); + ret = sd->ops->video->s_stream(sd, enable); if (!enable && ret < 0) { From patchwork Fri Apr 5 09:14:21 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Tomi Valkeinen X-Patchwork-Id: 786645 Received: from perceval.ideasonboard.com (perceval.ideasonboard.com [213.167.242.64]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 03F1116078F; Fri, 5 Apr 2024 09:14:46 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=213.167.242.64 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1712308488; cv=none; b=Iw0jI1+3PoXJsPrthmye28Z0osWLglNrKBqTLDI9eg07IqKs5hX+BmV5GCEKhi4JnETOoJYdP25tu8W2XCSYfL1EmsQtzKrwEjSxBF8Z7DsonFrRjEk7T+jZJl+thGu9p5BKt40ZSe5JTJUhW++uNFzyzKB3+a1hx6BJgK5GpGE= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1712308488; c=relaxed/simple; bh=ELI8oewYYbbwnpIW88NGWIlncp1y6aSu9PXgBDCA0Ko=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=Vih7QPfZ38zRAzGlQIsw8dxS0UPrS11CHmaJylts4RI8YJ2pZ1i95Q4C07cyCOXHbhJ/pR9pVDHYJPkLJVNBB/bQLFSgp7L/f9MwIP9kb790tfUpCjvN6wd+8/jgnVvvL8SQbqXQaX8QB/3KeR1mGejaNy/wiQ8fywEJ/kVLR9w= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=none (p=none dis=none) header.from=ideasonboard.com; spf=pass smtp.mailfrom=ideasonboard.com; dkim=pass (1024-bit key) header.d=ideasonboard.com header.i=@ideasonboard.com header.b=I1M8DpC7; arc=none smtp.client-ip=213.167.242.64 Authentication-Results: smtp.subspace.kernel.org; dmarc=none (p=none dis=none) header.from=ideasonboard.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=ideasonboard.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (1024-bit key) header.d=ideasonboard.com header.i=@ideasonboard.com header.b="I1M8DpC7" Received: from [127.0.1.1] (91-154-34-181.elisa-laajakaista.fi [91.154.34.181]) by perceval.ideasonboard.com (Postfix) with ESMTPSA id CB2D6F0A; Fri, 5 Apr 2024 11:14:03 +0200 (CEST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=ideasonboard.com; s=mail; t=1712308444; bh=ELI8oewYYbbwnpIW88NGWIlncp1y6aSu9PXgBDCA0Ko=; h=From:Date:Subject:References:In-Reply-To:To:Cc:From; b=I1M8DpC741zgAa/IiVDMkphQWFwmbsOXnNcUpNvUWHi3P1qOXIKWAbqKgyp1lG+Jz 9uYr2X7Spm5XxU3hGsZLb7weBBd6v019vko38XEnPWOk55uWpXQ/udd3H63quP+Kbb LN9JRKdtzLUiTN//8IhxSqYeyK0viBS+QfN+CBZ8= From: Tomi Valkeinen Date: Fri, 05 Apr 2024 12:14:21 +0300 Subject: [PATCH v2 3/9] media: subdev: Add checks for subdev features Precedence: bulk X-Mailing-List: linux-media@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Message-Id: <20240405-enable-streams-impro-v2-3-22bca967665d@ideasonboard.com> References: <20240405-enable-streams-impro-v2-0-22bca967665d@ideasonboard.com> In-Reply-To: <20240405-enable-streams-impro-v2-0-22bca967665d@ideasonboard.com> To: Mauro Carvalho Chehab , Hans Verkuil , Laurent Pinchart , Sakari Ailus , Umang Jain Cc: linux-media@vger.kernel.org, linux-kernel@vger.kernel.org, Tomi Valkeinen X-Mailer: b4 0.13.0 X-Developer-Signature: v=1; a=openpgp-sha256; l=2128; i=tomi.valkeinen@ideasonboard.com; h=from:subject:message-id; bh=ELI8oewYYbbwnpIW88NGWIlncp1y6aSu9PXgBDCA0Ko=; b=owEBbQKS/ZANAwAIAfo9qoy8lh71AcsmYgBmD8D9YP56b5dScuJlvsojhKUzK6fiKF3/cSCKQ GEGoiQHDnmJAjMEAAEIAB0WIQTEOAw+ll79gQef86f6PaqMvJYe9QUCZg/A/QAKCRD6PaqMvJYe 9VTlD/9d0TZn2qXB95p/F5QJl/0QbXM6BS+xUH/BLnTkj+mPTo7YLfM6lE8fDiBp5UnKVWVfV1H WIKmjhOMAuDXo+AyN+I48TuIN6+SSBQn31ZqlYuF+8KsZVwI4ndY0TkmF/o2I8K4N1st5xsP+1B Xq75XMw6NSqZ1wW3hqMF/RBX0cz0jUQwy3WQsagruBhR5K0jYHdR75Bu2wlHmOE/twYYjc/Ilmk DigjghXTvyk9bqySBI7QlErJUK4B/+1OVrpBmos5iKGHybx9/AEJLTOJesrN45eyV3VrPbEZ6uR v+9F3O7SgWru666pZAVyzh+Gk9jKsuWdWG751A6UffKBW/Z/vtiGe9n/wI8CwjBWDJpte1/haaY 9nWjlbKiT2gzYpE1dwYUNnuIAjDndycKI5JidbGPwYU9zAMINsucRso97Dd6JMPxkBFQSltrWro CbAEMfrWcM0Na+Q4yEOBL81e3eq/FqCukxd+t80CHWk2lIaM9WS4iT/tXDLRwHoXO/X7YQL1Vpm lt8n0c42lgtBBroIgjAmHyyGfSps6Ai8wA9xMIdA1Yr26/qKTWjlqvToSvMf6ocwiDYJARxy+Vp RuIw8Io/BYiWZxHyRG6a7RT6wQiwB2HoVQP9LyXmoFC0IqMN1trxIxZGpgetdYnAAaTiJ+Z97oP T6GlZq3P3RwGttg== X-Developer-Key: i=tomi.valkeinen@ideasonboard.com; a=openpgp; fpr=C4380C3E965EFD81079FF3A7FA3DAA8CBC961EF5 Add 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. Signed-off-by: Tomi Valkeinen --- drivers/media/v4l2-core/v4l2-subdev.c | 27 +++++++++++++++++++++++++++ 1 file changed, 27 insertions(+) diff --git a/drivers/media/v4l2-core/v4l2-subdev.c b/drivers/media/v4l2-core/v4l2-subdev.c index c8124919b92c..a15a41576918 100644 --- a/drivers/media/v4l2-core/v4l2-subdev.c +++ b/drivers/media/v4l2-core/v4l2-subdev.c @@ -1532,6 +1532,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)) From patchwork Fri Apr 5 09:14:23 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Tomi Valkeinen X-Patchwork-Id: 786644 Received: from perceval.ideasonboard.com (perceval.ideasonboard.com [213.167.242.64]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 3D9E3161319; Fri, 5 Apr 2024 09:14:50 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=213.167.242.64 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1712308491; cv=none; b=KCTYtdMvwUiNAi06OFPYOzbjdRTpsV5rBmSeluK1cM0dCeBmkJEKSR59I8vTcjqH2dYVhQEegJ4JzcXuQbFdKTQW/WHJKzDsJeCb52uK77MGdZ3wOHopYpbMbFzCxxiGoqj+fQk51EoTTKuYYR/GOSmR1NDT8d6JMFLHz/i5uuY= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1712308491; c=relaxed/simple; bh=kSZwpWlf514IoxE2BoF5xBV0zVQADm4oWeSxvTLDfLI=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=mz+gJsF6+CWuMvVpOm5EkFRUZvAyptKMkyZrt+37apaj+k8c0NbTX05nhCna1LAeqrtxe6up63Q2PkTcty57xv3MHk1PVnXQWUcZ4tV5SbazYJHoZChmM5TlfvMomTue9R8ZnGtihmaUm29k/LxO8sMff3mR1h525hXU0s51hqc= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=none (p=none dis=none) header.from=ideasonboard.com; spf=pass smtp.mailfrom=ideasonboard.com; dkim=pass (1024-bit key) header.d=ideasonboard.com header.i=@ideasonboard.com header.b=YaYEbuEl; arc=none smtp.client-ip=213.167.242.64 Authentication-Results: smtp.subspace.kernel.org; dmarc=none (p=none dis=none) header.from=ideasonboard.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=ideasonboard.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (1024-bit key) header.d=ideasonboard.com header.i=@ideasonboard.com header.b="YaYEbuEl" Received: from [127.0.1.1] (91-154-34-181.elisa-laajakaista.fi [91.154.34.181]) by perceval.ideasonboard.com (Postfix) with ESMTPSA id E1A03FD6; Fri, 5 Apr 2024 11:14:04 +0200 (CEST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=ideasonboard.com; s=mail; t=1712308445; bh=kSZwpWlf514IoxE2BoF5xBV0zVQADm4oWeSxvTLDfLI=; h=From:Date:Subject:References:In-Reply-To:To:Cc:From; b=YaYEbuEldqMM86ipY52eBVgNNrR6ppMWyxfZL08RCbKe03mrgy0Cbm+uZw/HAfYhc mk/T4fWvEG5okMMKpNvH3S/39E3F39843a8mgD5GI5ICvtY3yLhqSfp5CwlAb3h+Ak t4gW/kuhAz/4uTQhOH4ZM2Eawbljr6M1/C8f+xGY= From: Tomi Valkeinen Date: Fri, 05 Apr 2024 12:14:23 +0300 Subject: [PATCH v2 5/9] media: subdev: Improve v4l2_subdev_enable/disable_streams_fallback Precedence: bulk X-Mailing-List: linux-media@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Message-Id: <20240405-enable-streams-impro-v2-5-22bca967665d@ideasonboard.com> References: <20240405-enable-streams-impro-v2-0-22bca967665d@ideasonboard.com> In-Reply-To: <20240405-enable-streams-impro-v2-0-22bca967665d@ideasonboard.com> To: Mauro Carvalho Chehab , Hans Verkuil , Laurent Pinchart , Sakari Ailus , Umang Jain Cc: linux-media@vger.kernel.org, linux-kernel@vger.kernel.org, Tomi Valkeinen X-Mailer: b4 0.13.0 X-Developer-Signature: v=1; a=openpgp-sha256; l=6393; i=tomi.valkeinen@ideasonboard.com; h=from:subject:message-id; bh=kSZwpWlf514IoxE2BoF5xBV0zVQADm4oWeSxvTLDfLI=; b=owEBbQKS/ZANAwAIAfo9qoy8lh71AcsmYgBmD8D+svIbNaDM3jU+EcHLWTydCsd3mgnkMnUCt eeefUkqioeJAjMEAAEIAB0WIQTEOAw+ll79gQef86f6PaqMvJYe9QUCZg/A/gAKCRD6PaqMvJYe 9VRkEACXoeofMoo36MK284aCz5Y9k/f2q9RN7fLo4P66PNbTuDTOQWkxhF1/wS+HJpKU2fMnd0Q 2oaKmvzw3I00og/SdfAm+W/uokqavBjcMuWQorFElDcRancImCy1Jba5+0huJabSPle9Ba2IpRO gUxwhpxLw/GYT9w6LF4jLIs0wAiuwUfrLOmFKenoJ/fYh6qidjFd4cUkcGqNYyt3pWk7JDtaxLY AVtZ5987X47uYTfCQNzbn3/BNvrD81eWnD22JCCfY5rO1ynvGneFaQFMsysLKCJDWffevcnlnkc I21dOtWObgcfac3muaNlp6qCXSwjOIPts1f5wgOtn7l+fSr3kfa1m5yb4U4VHAAipzo5NkRvd2d OF58Y2/RQ1Z8jV++epDn7wA7eS1QPBlT0ARokkTkm4MzWsanSJyQgfpzUCY2lqFg5TAFhT9Ej95 bSBMhfLIi5NN4aSdic352S5XpwLmadwU0NpsM2MNaoZj8zgO1wxk3vlDmqQh8J2e/6n4v+fuMDX G8oQuk2eOYNW/n3MnKeHU1hlwkNiBHUg5U0DDDwefHMRw/FjRXCzTSvHa1AkDa6Kds9ls4CQLY+ WEdOJryhm1Z8jQPSsUEjw13QqiWBrKhjnAS160jREiF4DLRxTDOqf4RKy+QJ/mIB4ODjLPw4Oa+ zcU+w1o29CVvN0Q== X-Developer-Key: i=tomi.valkeinen@ideasonboard.com; a=openpgp; fpr=C4380C3E965EFD81079FF3A7FA3DAA8CBC961EF5 v4l2_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. Signed-off-by: Tomi Valkeinen --- drivers/media/v4l2-core/v4l2-subdev.c | 68 ++++++++++++++++++++--------------- include/media/v4l2-subdev.h | 9 +++-- 2 files changed, 44 insertions(+), 33 deletions(-) diff --git a/drivers/media/v4l2-core/v4l2-subdev.c b/drivers/media/v4l2-core/v4l2-subdev.c index 94483b238f2a..764d61636765 100644 --- a/drivers/media/v4l2-core/v4l2-subdev.c +++ b/drivers/media/v4l2-core/v4l2-subdev.c @@ -2103,37 +2103,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 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; } @@ -2220,37 +2226,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 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; } diff --git a/include/media/v4l2-subdev.h b/include/media/v4l2-subdev.h index f55d03e0acc1..d6867511e9cf 100644 --- a/include/media/v4l2-subdev.h +++ b/include/media/v4l2-subdev.h @@ -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. * @streaming_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 streaming_enabled; }; From patchwork Fri Apr 5 09:14:25 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Tomi Valkeinen X-Patchwork-Id: 786643 Received: from perceval.ideasonboard.com (perceval.ideasonboard.com [213.167.242.64]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 88C5216191D; Fri, 5 Apr 2024 09:14:53 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=213.167.242.64 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1712308495; cv=none; b=P6m7B83mkbEclE7VlZccTocl8XWuls5zaRRAC67yphJCZaDS3qNn/YWe7w+QPLHYa8lD1y+wRk+33JGUAzWNsVPH0q+pnR6yarrU/I9j7hWkQDF44gCcwvMIcNeW3guYIMyHaPP6ll8+sfePf/RJ7cqK+USzwPpB/uq4aYT53ZM= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1712308495; c=relaxed/simple; bh=iU08g9MecKbH8Kv5xSp2Mtj+ZCNUisKoXNwFY/0rf5Y=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=Pu73sarGX3iUcYWoqMYXVKVoM85N2GR6MHLHArURSkeLPwzAARmTM7Jvnbe36lM86IS6uQOMdE/O9rxS2/+Oo7U2YnJyPO6ZhpnxWaMYw9qo5MUUU1aL8Gi41cBBE1zX8QYdNynuzk0iEECeya7HtJZE+SH8kP4RHX9RJml7lYc= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=none (p=none dis=none) header.from=ideasonboard.com; spf=pass smtp.mailfrom=ideasonboard.com; dkim=pass (1024-bit key) header.d=ideasonboard.com header.i=@ideasonboard.com header.b=tUj2wrdA; arc=none smtp.client-ip=213.167.242.64 Authentication-Results: smtp.subspace.kernel.org; dmarc=none (p=none dis=none) header.from=ideasonboard.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=ideasonboard.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (1024-bit key) header.d=ideasonboard.com header.i=@ideasonboard.com header.b="tUj2wrdA" Received: from [127.0.1.1] (91-154-34-181.elisa-laajakaista.fi [91.154.34.181]) by perceval.ideasonboard.com (Postfix) with ESMTPSA id 01F9711CF; Fri, 5 Apr 2024 11:14:05 +0200 (CEST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=ideasonboard.com; s=mail; t=1712308446; bh=iU08g9MecKbH8Kv5xSp2Mtj+ZCNUisKoXNwFY/0rf5Y=; h=From:Date:Subject:References:In-Reply-To:To:Cc:From; b=tUj2wrdAYMj8fOFeETnfOj/+IEN5yUDkVBEBMN3r2JH5aQIznvYIdfLMG1oiBf2io rQYhiAftK1K1l/HCBVDi4pLvUeyRNkZquw7kT6UKSkfwEY1gweOYsvobkZuGiEjZNo upG5GSFddl3lx1NpuWPqSdKZYXy9pi4WHg1JZmQk= From: Tomi Valkeinen Date: Fri, 05 Apr 2024 12:14:25 +0300 Subject: [PATCH v2 7/9] media: subdev: Support privacy led in v4l2_subdev_enable/disable_streams() Precedence: bulk X-Mailing-List: linux-media@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Message-Id: <20240405-enable-streams-impro-v2-7-22bca967665d@ideasonboard.com> References: <20240405-enable-streams-impro-v2-0-22bca967665d@ideasonboard.com> In-Reply-To: <20240405-enable-streams-impro-v2-0-22bca967665d@ideasonboard.com> To: Mauro Carvalho Chehab , Hans Verkuil , Laurent Pinchart , Sakari Ailus , Umang Jain Cc: linux-media@vger.kernel.org, linux-kernel@vger.kernel.org, Tomi Valkeinen X-Mailer: b4 0.13.0 X-Developer-Signature: v=1; a=openpgp-sha256; l=1874; i=tomi.valkeinen@ideasonboard.com; h=from:subject:message-id; bh=iU08g9MecKbH8Kv5xSp2Mtj+ZCNUisKoXNwFY/0rf5Y=; b=owEBbQKS/ZANAwAIAfo9qoy8lh71AcsmYgBmD8D/5HQ/hSya32BORPX6e587qoHIlAHE+GdWS aqL6JF0gymJAjMEAAEIAB0WIQTEOAw+ll79gQef86f6PaqMvJYe9QUCZg/A/wAKCRD6PaqMvJYe 9f8dD/4yyRK+YjsWX74ZICp2NiJvkgX9cbiifBMWo3Eb6tvnVso9luTmUkoPerjTNOTauS4QlcK Dl3MW+88cw0+6kqdtt+bxPaaXYW+9anugGL3ISxm9hEZW2XTD1a7akYmFlBREHCaG5VAmNcVdnc pLg/SJfpA21NsqNDCqby0XWsr+rQPy9XxyZbt+9UC4ZgJVorBq1TP/d0UxyvRhvMpfvDbnCXeMd gVYi/cgIUTaxnC0nOwJWW88FoDQz89TaPgXDeACvEFHAJxB5T4pb3fw+OniesSdeAQKMobr4Pzo C1q93c1568H8cf8kAJJfiWUo4CrIVaV5voxH7vbWg/RjtbWvh7BCXNpLiZv4WDiqzWTVnl/NK5d nXv7lZZH0dexScPSRxse2qOvHbyq5uaduCp7aAODQbJxsjsCUgX2CzBDuwbzy9wr1fz9VW9718S c20Zy47pDIhb71tt3QIVLcnLmSsmPd0EZvriPufAeJJeifbALNK3F2RsR/YXW2M0gKhlyw0/DNN gxHtFxqcFsTQGz6ejQwNs9T5GfHVkyp1ucfPFe64gMvdxbPTjsK3Y0KjM+bIFDloppZoHZWB34V WC90b4MzdBgliz4y/G24w6rK4dqwxP0FymUn3Ib7y4Er/tuTYa9Oo01jsdnaMJGOm9tsGK1b3j9 WA6jmK2mDTd70xQ== X-Developer-Key: i=tomi.valkeinen@ideasonboard.com; a=openpgp; fpr=C4380C3E965EFD81079FF3A7FA3DAA8CBC961EF5 We support camera privacy leds with the .s_stream, in call_s_stream, but we don't have that support when the subdevice implements .enable/disable_streams. 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. Signed-off-by: Tomi Valkeinen --- drivers/media/v4l2-core/v4l2-subdev.c | 12 ++++++++++++ 1 file changed, 12 insertions(+) diff --git a/drivers/media/v4l2-core/v4l2-subdev.c b/drivers/media/v4l2-core/v4l2-subdev.c index b4981447961a..015f2fb423c9 100644 --- a/drivers/media/v4l2-core/v4l2-subdev.c +++ b/drivers/media/v4l2-core/v4l2-subdev.c @@ -2149,6 +2149,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; @@ -2197,6 +2198,11 @@ 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); + + if (!already_streaming) + v4l2_subdev_enable_privacy_led(sd); + /* Call the .enable_streams() operation. */ ret = v4l2_subdev_call(sd, pad, enable_streams, state, pad, streams_mask); @@ -2216,6 +2222,9 @@ int v4l2_subdev_enable_streams(struct v4l2_subdev *sd, u32 pad, } done: + if (ret && !already_streaming) + v4l2_subdev_disable_privacy_led(sd); + v4l2_subdev_unlock_state(state); return ret; @@ -2339,6 +2348,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; From patchwork Fri Apr 5 09:14:27 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Tomi Valkeinen X-Patchwork-Id: 786642 Received: from perceval.ideasonboard.com (perceval.ideasonboard.com [213.167.242.64]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 9F41E1649A7; Fri, 5 Apr 2024 09:14:56 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=213.167.242.64 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1712308498; cv=none; b=gQkfCKArezPJthtC9Hj5q10PKLy8MBpVBV0UTHF/AdwVI/7tM7GpLnwGG7ZyENBwR4+35ZLiegVK8ZlBvwm/9H6N8dxfJN9pxwXiwt+k2/j4neKV35RbCZ6pzWnNaJ+uj/ZxjwdhpLdXVNoo+A/Z03GWiZSssHYcE0QWon7+v3U= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1712308498; c=relaxed/simple; bh=VJ1VCMP8/mqpDK0x4H1ZKQ5lnAJENk/9mk7rosoMzQU=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=uJqkHPl6CPzdqcQniY9g4amHLeO8XoUNjbKgwDIUKCNGzl/OR8gwM3/tynB1u5RMyYYjvSKLk6ewl+rR2cMlktDukOEnVR9uqV4dKKdAc0lSrhPEwXgg/C2AlDk2KSGrikf9XeauuFWHmi/iJh9iOmdJKr4cAGoyzVH0bW7t0Mo= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=none (p=none dis=none) header.from=ideasonboard.com; spf=pass smtp.mailfrom=ideasonboard.com; dkim=pass (1024-bit key) header.d=ideasonboard.com header.i=@ideasonboard.com header.b=p051XxgA; arc=none smtp.client-ip=213.167.242.64 Authentication-Results: smtp.subspace.kernel.org; dmarc=none (p=none dis=none) header.from=ideasonboard.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=ideasonboard.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (1024-bit key) header.d=ideasonboard.com header.i=@ideasonboard.com header.b="p051XxgA" Received: from [127.0.1.1] (91-154-34-181.elisa-laajakaista.fi [91.154.34.181]) by perceval.ideasonboard.com (Postfix) with ESMTPSA id 16EF211D1; Fri, 5 Apr 2024 11:14:07 +0200 (CEST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=ideasonboard.com; s=mail; t=1712308447; bh=VJ1VCMP8/mqpDK0x4H1ZKQ5lnAJENk/9mk7rosoMzQU=; h=From:Date:Subject:References:In-Reply-To:To:Cc:From; b=p051XxgABuRfg4oW3WGR8YWGadbZ46vhMeQEq8+ohggMxUkwtnxZXAhtC9VluaQf0 bh2XchtN3me4lK33i717neqWsvxj2M7BLgXnljMEPSm1LRBUpJErhP3f5eYIpMcjA3 Eu4TAHj9YrrB+ekusk7nrAd/p/pmWDFh1TaONt4Q= From: Tomi Valkeinen Date: Fri, 05 Apr 2024 12:14:27 +0300 Subject: [PATCH v2 9/9] media: subdev: Support single-stream case in v4l2_subdev_enable/disable_streams() Precedence: bulk X-Mailing-List: linux-media@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Message-Id: <20240405-enable-streams-impro-v2-9-22bca967665d@ideasonboard.com> References: <20240405-enable-streams-impro-v2-0-22bca967665d@ideasonboard.com> In-Reply-To: <20240405-enable-streams-impro-v2-0-22bca967665d@ideasonboard.com> To: Mauro Carvalho Chehab , Hans Verkuil , Laurent Pinchart , Sakari Ailus , Umang Jain Cc: linux-media@vger.kernel.org, linux-kernel@vger.kernel.org, Tomi Valkeinen X-Mailer: b4 0.13.0 X-Developer-Signature: v=1; a=openpgp-sha256; l=10582; i=tomi.valkeinen@ideasonboard.com; h=from:subject:message-id; bh=VJ1VCMP8/mqpDK0x4H1ZKQ5lnAJENk/9mk7rosoMzQU=; b=owEBbQKS/ZANAwAIAfo9qoy8lh71AcsmYgBmD8D/jVZ+ZihNEv5GC+cr6+1vhyCuHMXQfu9hK y7d9U/kc0aJAjMEAAEIAB0WIQTEOAw+ll79gQef86f6PaqMvJYe9QUCZg/A/wAKCRD6PaqMvJYe 9VDID/9437Z63Id59BceWArJc6rdY1IVWPYU3m41p7iZYdoNmYWdkPeg+JRYD41W9IKtzeNNxYh C6aPHSnuSXTaUXpN+8UD0b417budMldyQPqzSgtMDPXoEgNjxSB+mT2bkkxjUJxb+WgERXoxv76 NYux5NmJv0AvwjRCmamKhXuhrqALOST9H9C7byiPjVk5/xrWVGg/MvW47TLShzOJvvTvSdLE9PL sBWbWBWSqt+2GNwKL6ALAUWjkUj2GX9RsIw8X0coDXZLisGQ1q4WNc1wq3CPV1trn+MwkOPmSJ2 2ZXYwhX6hcF/oEdWVI1oTPzqhPFdLD8Oo/LLJDFAw3If2DMYX0wJZS5KWD7bWHw+cXuQwKNEzj3 x0lV0BRYhV538zR4XQZzJp97ngilhJP3+dZSi/oWGhwlHhEjF3fMbmtdgU8ueRJjF34IAM5uO3n tA9TTZKW3VFZHNk+8vvAZebNvsmDEqOTKDNIMaSG1CKaPG8Y2rZRBlRxIZ9EukiR8ipCBjbRoWr ZMNQxy1Hzf8GaOmM7+BG/aeBMCyVC2/2Wa7ReqW/6exm81xKWOD7OI9Gp04N1w8c2K0atfg4v6y 9HajlI8HMQNvVK2gYbpXe2caS9cx0vUIELd+tDatvBhXspdI2srC40eoZsEG3wF+cqpJ/SMFsDe MnJz9WeTDWeQuyg== X-Developer-Key: i=tomi.valkeinen@ideasonboard.com; a=openpgp; fpr=C4380C3E965EFD81079FF3A7FA3DAA8CBC961EF5 At 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. Signed-off-by: Tomi Valkeinen --- drivers/media/v4l2-core/v4l2-subdev.c | 194 +++++++++++++++------------------- 1 file changed, 83 insertions(+), 111 deletions(-) diff --git a/drivers/media/v4l2-core/v4l2-subdev.c b/drivers/media/v4l2-core/v4l2-subdev.c index 6c3c9069f1e2..12b90a1cdf6f 100644 --- a/drivers/media/v4l2-core/v4l2-subdev.c +++ b/drivers/media/v4l2-core/v4l2-subdev.c @@ -2105,6 +2105,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); + if (sd->enabled_pads & BIT_ULL(pad)) + *enabled_streams = BIT_ULL(0); + return; + } + *found_streams = 0; *enabled_streams = 0; @@ -2127,6 +2134,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; @@ -2137,51 +2152,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 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) { @@ -2190,21 +2160,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 @@ -2232,12 +2214,21 @@ int v4l2_subdev_enable_streams(struct v4l2_subdev *sd, u32 pad, already_streaming = v4l2_subdev_is_streaming(sd); - if (!already_streaming) - v4l2_subdev_enable_privacy_led(sd); + if (!use_s_stream) { + if (!already_streaming) + v4l2_subdev_enable_privacy_led(sd); + + /* 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; + } - /* Call the .enable_streams() operation. */ - ret = v4l2_subdev_call(sd, pad, enable_streams, state, pad, - streams_mask); if (ret) { dev_dbg(dev, "enable streams %u:%#llx failed: %d\n", pad, streams_mask, ret); @@ -2248,33 +2239,32 @@ int v4l2_subdev_enable_streams(struct v4l2_subdev *sd, u32 pad, v4l2_subdev_set_streams_enabled(sd, state, pad, streams_mask, true); done: - if (ret && !already_streaming) - v4l2_subdev_disable_privacy_led(sd); + if (!use_s_stream) { + if (ret && !already_streaming) + v4l2_subdev_disable_privacy_led(sd); - v4l2_subdev_unlock_state(state); + 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 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; /* @@ -2284,46 +2274,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 @@ -2349,9 +2309,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); @@ -2361,10 +2331,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; }