From nobody Thu Oct 2 00:46:10 2025 Received: from mail-wm1-f41.google.com (mail-wm1-f41.google.com [209.85.128.41]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id D5F253002A6 for ; Wed, 24 Sep 2025 14:51:56 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.128.41 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1758725518; cv=none; b=PdQm9m5egcjWOxdssIVSQ8y2X+ydc3e2wLwtXyRR8xwtg6nMwg4YOYGRkb+Z37d+EY3JQATfUflpHlmy+nmYukZn+sX6QF4OrgoLih+931VHk5jDiOTA/xVxuDHYt/orBWRcaIMErVibTLEVRn0FMAJTb8Njw881G5BuDAkyYnA= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1758725518; c=relaxed/simple; bh=L2kLAKhXcPRTSxYID5+lqGdmVixmb8cY89yQVUKyTsw=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=TmXYfxGBhT8xRvhox4VoyzaxwgG2MoW/OeI/xR4TrQp01odf1yGxraC7h8utdiUfjZ1/p2JweCrZVkzutNrVLWjNvMqFief0bwLFiY0cTHTE5jEYHKGZxmLTgRY8nXhd/hopoeYqDVjWNReCkEdkt7Affl9ul+GWdFIDZVcWgwg= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=none (p=none dis=none) header.from=bgdev.pl; spf=none smtp.mailfrom=bgdev.pl; dkim=pass (2048-bit key) header.d=bgdev-pl.20230601.gappssmtp.com header.i=@bgdev-pl.20230601.gappssmtp.com header.b=e0lxZtHL; arc=none smtp.client-ip=209.85.128.41 Authentication-Results: smtp.subspace.kernel.org; dmarc=none (p=none dis=none) header.from=bgdev.pl Authentication-Results: smtp.subspace.kernel.org; spf=none smtp.mailfrom=bgdev.pl Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=bgdev-pl.20230601.gappssmtp.com header.i=@bgdev-pl.20230601.gappssmtp.com header.b="e0lxZtHL" Received: by mail-wm1-f41.google.com with SMTP id 5b1f17b1804b1-46d25f99d5aso8003515e9.0 for ; Wed, 24 Sep 2025 07:51:56 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=bgdev-pl.20230601.gappssmtp.com; s=20230601; t=1758725515; x=1759330315; darn=vger.kernel.org; h=cc:to:in-reply-to:references:message-id:content-transfer-encoding :mime-version:subject:date:from:from:to:cc:subject:date:message-id :reply-to; bh=V0Q+Hgya9r+CWJ27IcqRYKkvlXmEyTvOuBCqoT3y8qw=; b=e0lxZtHLY+v0rBmlEbUurgnddp5kvZvgYOJbyCrfZMJBKNV2jPOD+ZMWL/cVDu6alT WVT22A7bGD+QsL73jovvMsZepws1MokS3LbFlQa7sIVtOMoBkMdyJ90fAeSy3uuLCV/z 9ITaMZW30GmCShAm508ips6VzY8JNchv53v78GjQpljyHTFZebMT9iurFw9kr2ii67oP w89oqJJtsoWAO6k2LNQv7oJYOSUgvtzf09h18HGXCN2vzAPZTQlnEgwO6GTsmFzcYCFf 2OJ/zzFM7ssPpsuMXJX+1jcUTC6zep0t0pTj745K3uOrk0Acnk4qvGOWodyJm+WlZ1IG sSRg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1758725515; x=1759330315; h=cc:to:in-reply-to:references:message-id:content-transfer-encoding :mime-version:subject:date:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=V0Q+Hgya9r+CWJ27IcqRYKkvlXmEyTvOuBCqoT3y8qw=; b=lHouxtcjTkXEMGZ8WRZZJfFjpmiav2g5NnQqFKiRc8mH9jz3sft+uzmZB3gVOQWRtX QkKzZLukwfh2OZmNiVj1fkKojVA2gGHMf+ca0wqnTvFzGatmhNJOwfVXcTeHYEu08cJ8 o8wLk6O2qGBJK/+AQEMSFcaflAriwoiBcs+edeJxDbnXwPmjN/3On0PiJq7/IpWBE8u9 B+Fhn4i8BYbTSlmFsRpp6Q6YTszjVIIY/XXMW9d6gVXAGkHjktjqw9uAhqxhK7hFCbw0 7dWVhAQXG8ArY6SZmeGp/CDpwwgUVK85F8g0jnGWeyCtXQG5IzzMflJlqPL3vPrYm346 Hodg== X-Forwarded-Encrypted: i=1; AJvYcCVDRsp1ug7t8V+gF8xwpTVZcR2ukrZ+ms/k7OVud2rCM+ivMVL3smgQo4vgGZnyGErWvS5MngJz15ESa1A=@vger.kernel.org X-Gm-Message-State: AOJu0YzT72wH58cQoBnaj22DB+Em+tL2mSolEG/WvoGPB8q6ot1bZwYu tfZMzrkPS7yzhT7bCLK2xfTyfVSzr3Kq6JGyWj0czBHPcwCow+riHvkep7PLJrAocxY= X-Gm-Gg: ASbGncta5xGRMSmTewDiYDFVL6HgD64qX0SpyCndc6DnESHoAVF0mWi0UWjqd2KG+rJ FBKbwpiJTskoGu9WSJMBOTqwMSZlRSy8xh1mdYPcdFClv7XSw+UxwxhsN3b4BRW90d4YGnu6R8d rxxgTXGYXcUCUn5Orsdut4FVRRyEHxtcj9SoM0NX4srFX9XT0oERyYO1Kf+mB0qdkHvc8BSTZAZ QgaZ8IvKblnSJPJ2XozZCmQKSjo3D6Dbx6nFDLUnmFxFMUVUzcRTRB4GpbpSDBz7bBnfKeJnn3e lTRzdo6LnICVcmS5qKh7WII1Me0+LVz3BGeMaPdUCAKyD830QhAi6AC6kNoP/vgpHepkd4cT5Dj R0c51EoTK5syQkBU6pn2edfJt2euY X-Google-Smtp-Source: AGHT+IHqrlf5Iy0gafewEVEvZvdqGPtxzn/dahd6Ieio03KFz2MLsdyrnS63HEdvlLZHwR/e4CQuAg== X-Received: by 2002:a05:600c:c1c8:20b0:45d:5c71:769d with SMTP id 5b1f17b1804b1-46e2b52c35amr23884575e9.8.1758725514877; Wed, 24 Sep 2025 07:51:54 -0700 (PDT) Received: from [127.0.1.1] ([2a01:cb1d:dc:7e00:1729:c9b6:7a46:b4a3]) by smtp.gmail.com with ESMTPSA id ffacd0b85a97d-3ee0fbc7188sm29514750f8f.37.2025.09.24.07.51.52 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 24 Sep 2025 07:51:53 -0700 (PDT) From: Bartosz Golaszewski Date: Wed, 24 Sep 2025 16:51:29 +0200 Subject: [PATCH RFC 1/9] gpio: wcd934x: mark the GPIO controller as sleeping Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Message-Id: <20250924-gpio-shared-v1-1-775e7efeb1a3@linaro.org> References: <20250924-gpio-shared-v1-0-775e7efeb1a3@linaro.org> In-Reply-To: <20250924-gpio-shared-v1-0-775e7efeb1a3@linaro.org> To: Kees Cook , Mika Westerberg , Dmitry Torokhov , Andrew Morton , Linus Walleij , Manivannan Sadhasivam , Rob Herring , Krzysztof Kozlowski , Conor Dooley , Saravana Kannan , Greg Kroah-Hartman , Andy Shevchenko , Bartosz Golaszewski , Catalin Marinas , Will Deacon , Srinivas Kandagatla , Liam Girdwood , Mark Brown , Jaroslav Kysela , Takashi Iwai Cc: linux-hardening@vger.kernel.org, linux-kernel@vger.kernel.org, linux-gpio@vger.kernel.org, linux-arm-kernel@lists.infradead.org, linux-sound@vger.kernel.org, linux-arm-msm@vger.kernel.org, Bartosz Golaszewski X-Mailer: b4 0.14.2 X-Developer-Signature: v=1; a=openpgp-sha256; l=990; i=bartosz.golaszewski@linaro.org; h=from:subject:message-id; bh=+onLqCs+uky6KqRfHsDH/gKs++nVX/GXHjjSwDpjMnY=; b=owEBbQKS/ZANAwAKARGnLqAUcddyAcsmYgBo1AWFZY+Dx2G8yimcnZUw4X/JDBSCEab4BzQX0 SEHR9ic5oyJAjMEAAEKAB0WIQQWnetsC8PEYBPSx58Rpy6gFHHXcgUCaNQFhQAKCRARpy6gFHHX csl7D/93a8AjEBhJdr57hZV94lQ6L3oHzmrrx5+I11yewNKQjKjTiq/Sv7simTbkw5LqRHTNOOk QWOaGEuOezZILvfSLh1t7XubpcAX+zTbbff5+vb4ZdNe1XGw3g5MD5RLUzKZQ0hjOMJHU7L9tAJ NoggHvBT3EnG8Ws9nzAODXZt5TqCAudVYwg8tTt59kKaEXKVyQUpgfYieAEBx3nstzHVwhBZMsN PN/W57PhQSenmFgTdbS8wyVjzfM0yQvStz23TE80h/aC9XZT/OgLk/12DNudAF/HRKS5/Q3iuPS 2HKCzPlKXS+fjOKXLiTomcVP8ARRmUp8VToNMHo4J4KYtNQXi08TC6HgRORLT/1wWctRhPuhb61 OkA0dqVJVQGYlOElCn2+hsp5eNzF6oKi/t/I3jiVl7XiGyw8uvkoTWCUnNLGmIHFco/iJoLw7Kt sPE0BsweoKRZL6tWX9N9iebGP0cqbHMEsyPDeXu8SFvahdcdKtrNFDCksbyNqOKy+4aBmsmslUl SuxtbhyvNcNsX/RjP5FpdoDfQkcDHmiWoTFQvz1YGeGNIJeCLCBmFu+3Gbu4uBalakSNLTq5T40 g+otJPzjjKDtCQ1tClpK7Ad+moqy7orLr6M64tCCWKk2ukhBIo+iwX0F9X3nRRLdISs6m/qIoR+ N1Boo054QFUaFwA== X-Developer-Key: i=bartosz.golaszewski@linaro.org; a=openpgp; fpr=169DEB6C0BC3C46013D2C79F11A72EA01471D772 From: Bartosz Golaszewski The slimbus regmap passed to the GPIO driver down from MFD does not use fast_io. This means a mutex is used for locking and thus this GPIO chip must not sleep. Change the can_sleep switch in struct gpio_chip to true. Fixes: 59c324683400 ("gpio: wcd934x: Add support to wcd934x gpio controller= ") Signed-off-by: Bartosz Golaszewski --- drivers/gpio/gpio-wcd934x.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/drivers/gpio/gpio-wcd934x.c b/drivers/gpio/gpio-wcd934x.c index 4af504c23e6ff5ad2bad1d70a0c42e2fd91f0c7a..572b85e773700ea0740d3e4efc0= 6d3538f7e368e 100644 --- a/drivers/gpio/gpio-wcd934x.c +++ b/drivers/gpio/gpio-wcd934x.c @@ -103,7 +103,7 @@ static int wcd_gpio_probe(struct platform_device *pdev) chip->base =3D -1; chip->ngpio =3D WCD934X_NPINS; chip->label =3D dev_name(dev); - chip->can_sleep =3D false; + chip->can_sleep =3D true; =20 return devm_gpiochip_add_data(dev, chip, data); } --=20 2.48.1 From nobody Thu Oct 2 00:46:10 2025 Received: from mail-wm1-f44.google.com (mail-wm1-f44.google.com [209.85.128.44]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 806A530C604 for ; Wed, 24 Sep 2025 14:51:58 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.128.44 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1758725520; cv=none; b=WffZOmlG8vAqZl+wIEXUNRlh10H/UGBP9voh4+9RJpNeHm2gYBRR58bUrJzXJCYBQAvURcC/0Shm1Pe15C2oz5rI13RIHVN1KVUbtlGWKJd3kFX8jCcDNRAzTphk4U9t7Ow91WCQcJtjwyZ4wwsXayU4uCviiUF+tsND5rLVd8o= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1758725520; c=relaxed/simple; bh=BLrlpEi+Tf0y57g8++fj5PBGfPPtXYf9LwcXnw/5/Xc=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=dvk4e86opM6t9bdh7JG63FPmGnLi9tKCls+4HYbgJ+Q7S9tDkVoNaVoBID7otA1Pi/fXgPL5oPxCtwXAS9Hcf69rCfm8CcMLc3BOY9K9HtzgVC/Lp8q+MQ+j/av8GA8b8orW4l0+5Z5sop/8TNuC5pYm50UMkAc974FeFWtI4x8= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=none (p=none dis=none) header.from=bgdev.pl; spf=none smtp.mailfrom=bgdev.pl; dkim=pass (2048-bit key) header.d=bgdev-pl.20230601.gappssmtp.com header.i=@bgdev-pl.20230601.gappssmtp.com header.b=GVOA3tqW; arc=none smtp.client-ip=209.85.128.44 Authentication-Results: smtp.subspace.kernel.org; dmarc=none (p=none dis=none) header.from=bgdev.pl Authentication-Results: smtp.subspace.kernel.org; spf=none smtp.mailfrom=bgdev.pl Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=bgdev-pl.20230601.gappssmtp.com header.i=@bgdev-pl.20230601.gappssmtp.com header.b="GVOA3tqW" Received: by mail-wm1-f44.google.com with SMTP id 5b1f17b1804b1-46dfd711172so28242635e9.1 for ; Wed, 24 Sep 2025 07:51:58 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=bgdev-pl.20230601.gappssmtp.com; s=20230601; t=1758725517; x=1759330317; darn=vger.kernel.org; h=cc:to:in-reply-to:references:message-id:content-transfer-encoding :mime-version:subject:date:from:from:to:cc:subject:date:message-id :reply-to; bh=kUL6O2x/NPPlAHvfQ/3YG+cqGSjBZP8VuHP9QkP07I8=; b=GVOA3tqWY7GUvsrYvoO/WF+EwqzHCKZ8GpRQVlhd3g+C2hxDZx+MCZL29I1tCueiC3 0g1B8k39bNCpj3lTsn/MJLfUSsoW9EoqhxEQzUJfz97RMoGIuKpiRoS1LEb5ITJH61c4 XBBjZIUVWJdXqOkhBUtr6MISSrv4Iag+I4TA6nphxdJCBFrnjoqmqCLbxkEGlTOryOcO 8VjLIC4jMZObp2+pmgpoNIk2bkLmXeprQVnz7vcsh+KJ+heFPWDQoWQoM/O8JBnuX8tB nc5lTf8v7za587BTv+XzG5m2J+sA+4phiArsUR0ZlRT6pw/XJkULoWEYVqEyzfYXhcO8 oH9Q== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1758725517; x=1759330317; h=cc:to:in-reply-to:references:message-id:content-transfer-encoding :mime-version:subject:date:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=kUL6O2x/NPPlAHvfQ/3YG+cqGSjBZP8VuHP9QkP07I8=; b=NbVyjHBmXk0fSZ876yo4J6eHFoVB6VgAQKJpV0pnwn1NYu2sZuzpGgEd4WvlSP8E9B Ng/Q17LSvkKBK3RlrDulk2VerV5gFowKeUnlhObh1H0zX7bgTmC5i3q0Yk5HXaRUKulr dmuxQydv2xYfWAD/eujnXfy89KguFIvxVV4MXyIWxZ4+YiNAjtYC5G9VnW4bhS4bL+hH CnN2y1uq6Gwlt4HC7pvs00hVTKcjmxp7hGf3436C2dTUOLntG/sOKiMSrf5uL8fWYUlc Flq3rCdea7Kt3+6kbBoirhaRKoholwzcdv84R16pGNwCorgscAY7sQOora1F8X7bozci xGhg== X-Forwarded-Encrypted: i=1; AJvYcCVOQ4FtxEnkMPMgWl6p1fnV0HNfhoXrcezYz8mUxDZitFdQrT/E2xjAtuhtVbJoVCi8OOBFmgEobgs1UQQ=@vger.kernel.org X-Gm-Message-State: AOJu0YyEMWTIfffmvp6dN3iJbE6ks1c9vL0Lg1s4DhVc5rb0RsEhrjph hz4EIJU4fpSIXf211N6l/gYIYsiFAEF+VUkzmQpXHOK0dZ/o4FxH8VlwCGS8PoR31Mw= X-Gm-Gg: ASbGnctkWwVGlSvuUErm6a1kUaf/B0U89hc6LEHF+nBrp8BalIkLCHWF+t5mDs1gO/q CnL7YLjJp0MwdZ4JNTuQOavE5WC3r8hBp4t598bShJbAHacC8/BoYzG9nZC00CwrsZ6eDv8alYH /8+6bBz4fGobpfvIpv0t9AzId+Ht3mYj8fbMcruZPTKl2L6I0p6S5JU7uEhycuY4THdHmRXE/cq 8B+Yq2MmSUAt6xU4FxplwwXYZgjGbkZrQ7WgI+rTDPm47GfArGt+5KPoRAN5oJuMrH2Sv8y0Hwb XsGatfGcDypp543tYQcape8qAsGAr09OwVhEBoodK+yOtOL1BJzaUGsbmxTmbCKINd60ZGnsEAz 09fzVLQ42JXnOFR2nkh4EXOyhDpGZ X-Google-Smtp-Source: AGHT+IF/b8KtJGrO2c7FsOGp+7VILetZJbVWastKmh5680LJka6DmS8H0qiOcUh0QohfrhRcm7VWjg== X-Received: by 2002:a05:600c:4f49:b0:468:7a5a:725 with SMTP id 5b1f17b1804b1-46e329d499fmr1394735e9.1.1758725516760; Wed, 24 Sep 2025 07:51:56 -0700 (PDT) Received: from [127.0.1.1] ([2a01:cb1d:dc:7e00:1729:c9b6:7a46:b4a3]) by smtp.gmail.com with ESMTPSA id ffacd0b85a97d-3ee0fbc7188sm29514750f8f.37.2025.09.24.07.51.54 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 24 Sep 2025 07:51:55 -0700 (PDT) From: Bartosz Golaszewski Date: Wed, 24 Sep 2025 16:51:30 +0200 Subject: [PATCH RFC 2/9] string: provide strends() Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Message-Id: <20250924-gpio-shared-v1-2-775e7efeb1a3@linaro.org> References: <20250924-gpio-shared-v1-0-775e7efeb1a3@linaro.org> In-Reply-To: <20250924-gpio-shared-v1-0-775e7efeb1a3@linaro.org> To: Kees Cook , Mika Westerberg , Dmitry Torokhov , Andrew Morton , Linus Walleij , Manivannan Sadhasivam , Rob Herring , Krzysztof Kozlowski , Conor Dooley , Saravana Kannan , Greg Kroah-Hartman , Andy Shevchenko , Bartosz Golaszewski , Catalin Marinas , Will Deacon , Srinivas Kandagatla , Liam Girdwood , Mark Brown , Jaroslav Kysela , Takashi Iwai Cc: linux-hardening@vger.kernel.org, linux-kernel@vger.kernel.org, linux-gpio@vger.kernel.org, linux-arm-kernel@lists.infradead.org, linux-sound@vger.kernel.org, linux-arm-msm@vger.kernel.org, Bartosz Golaszewski X-Mailer: b4 0.14.2 X-Developer-Signature: v=1; a=openpgp-sha256; l=2913; i=bartosz.golaszewski@linaro.org; h=from:subject:message-id; bh=rk7LOdXp57F1p1eS/LT1Bp//+s+MccpAywVrjh9Sj2I=; b=owEBbQKS/ZANAwAKARGnLqAUcddyAcsmYgBo1AWFLLNKrVdT/LzU5mrMjyhofZl1pTrhJ6Uky MqoP34eGneJAjMEAAEKAB0WIQQWnetsC8PEYBPSx58Rpy6gFHHXcgUCaNQFhQAKCRARpy6gFHHX co6cD/4yaODnssjJFuoZ7p50b03D1KfIY95TO6+G69PuffncMCFpi+DH7pJfgY0IB08sl6Myb3j ZyO9FoV9P0DjRbv1mk0U41wjF7nRRWsNgqzGOjAFZXXccX2vo5WbZEz9M1qXGRqXffnCrqSIIgB JFuRGgJMxfYQDShBtPP5Anv6At1X1TgqNB4yBo+FlntLyczF0e2A2L2Y1YSqog7Nuj/kIHoSNgW kKLAEgabncRXTqPkEKF7FfPG1r6nnJsHc3/7ROcEJW1jtHg8vZgMCpt14W7TgVTGEwCc1hE+c7k qdTREcqK6mmS/7tNP7HMqmL6HEFADuvffkJPhGj2CBo/iOB5A6yAdzKjHm5jgLyMKqk0k/0IRw0 jrA1gVycBI4KQJQPJXWkekgV3no1O4Nq1Jb2ALEbBFlNqvI67bKYydRFtW3zejLuYB1WgLOc4Z1 P+bq+sc/9359/e6oxB3p+J1zH/0WaOYmv3OihFKCRnBAO6ANXR+ZVkVEYr7i0/lZTTA3QzQqGVw V/GC1cKCIT/ECMMVD8yW5TQVkudGOCmQ1lYz+RPzPrMuOSocBKUHIm8VuaaE4R7PFD5puC3Pty7 MSJJdskZZuaW/JrZeAnTfE2txMMqOWLEobceB/r28/vdQrre5Kd2bxCCHv3+aSB+shgxI6/6ht6 AvtofBUF192zP+Q== X-Developer-Key: i=bartosz.golaszewski@linaro.org; a=openpgp; fpr=169DEB6C0BC3C46013D2C79F11A72EA01471D772 From: Bartosz Golaszewski Implement a function for checking if a string ends with a different string and add its kunit test cases. Signed-off-by: Bartosz Golaszewski --- include/linux/string.h | 2 ++ lib/string.c | 19 +++++++++++++++++++ lib/tests/string_kunit.c | 13 +++++++++++++ 3 files changed, 34 insertions(+) diff --git a/include/linux/string.h b/include/linux/string.h index fdd3442c6bcbd786e177b6e87358e1065a0ffafc..16149404fc3aed535c094b9550f= 7bd7c9b44a0c9 100644 --- a/include/linux/string.h +++ b/include/linux/string.h @@ -562,4 +562,6 @@ static inline bool strstarts(const char *str, const cha= r *prefix) return strncmp(str, prefix, strlen(prefix)) =3D=3D 0; } =20 +bool strends(const char *str, const char *suffix); + #endif /* _LINUX_STRING_H_ */ diff --git a/lib/string.c b/lib/string.c index b632c71df1a5061256f556c40a30587cf45dce18..ac18313d9c52b38132f0bfdd952= cdec6b1354d76 100644 --- a/lib/string.c +++ b/lib/string.c @@ -880,3 +880,22 @@ void *memchr_inv(const void *start, int c, size_t byte= s) return check_bytes8(start, value, bytes % 8); } EXPORT_SYMBOL(memchr_inv); + +/** + * strends - Check if a string ends with another string. + * @str - NULL-terminated string to check against @suffix + * @suffix - NULL-terminated string defining the suffix to look for in @str + * + * Returns: + * True if @str ends with @suffix. False in all other cases. + */ +bool strends(const char *str, const char *suffix) +{ + unsigned int str_len =3D strlen(str), suffix_len =3D strlen(suffix); + + if (str_len < suffix_len) + return false; + + return !(strcmp(str + str_len - suffix_len, suffix)); +} +EXPORT_SYMBOL(strends); diff --git a/lib/tests/string_kunit.c b/lib/tests/string_kunit.c index 0ed7448a26d3aa0fe9e2a6a894d4c49c2c0b86e0..f9a8e557ba7734c9848d58ff986= 407d8000f52ee 100644 --- a/lib/tests/string_kunit.c +++ b/lib/tests/string_kunit.c @@ -602,6 +602,18 @@ static void string_test_memtostr(struct kunit *test) KUNIT_EXPECT_EQ(test, dest[7], '\0'); } =20 +static void string_test_strends(struct kunit *test) +{ + KUNIT_EXPECT_TRUE(test, strends("foo-bar", "bar")); + KUNIT_EXPECT_TRUE(test, strends("foo-bar", "-bar")); + KUNIT_EXPECT_TRUE(test, strends("foobar", "foobar")); + KUNIT_EXPECT_TRUE(test, strends("foobar", "")); + KUNIT_EXPECT_FALSE(test, strends("bar", "foobar")); + KUNIT_EXPECT_FALSE(test, strends("", "foo")); + KUNIT_EXPECT_FALSE(test, strends("foobar", "ba")); + KUNIT_EXPECT_TRUE(test, strends("", "")); +} + static struct kunit_case string_test_cases[] =3D { KUNIT_CASE(string_test_memset16), KUNIT_CASE(string_test_memset32), @@ -623,6 +635,7 @@ static struct kunit_case string_test_cases[] =3D { KUNIT_CASE(string_test_strlcat), KUNIT_CASE(string_test_strtomem), KUNIT_CASE(string_test_memtostr), + KUNIT_CASE(string_test_strends), {} }; =20 --=20 2.48.1 From nobody Thu Oct 2 00:46:10 2025 Received: from mail-wm1-f44.google.com (mail-wm1-f44.google.com [209.85.128.44]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 5AD3030CDA9 for ; Wed, 24 Sep 2025 14:52:00 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.128.44 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1758725523; cv=none; b=Ad5+rwrCwh4kDcmVNOmaI9HBL9778LEGJG4q/ey6E5wxrLeHB4OwWIEtxeVbfujPm6nj2r/5SQXb05B8kOR/RO00Hbz177erHyeoou7x9S3ZhzcsOcgWNg4HZiE+IwPPFuVrUp+KYoUq1psiImvRbYNDca0njr0kRMlnfMB/WOA= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1758725523; c=relaxed/simple; bh=2qMqnWq/naOFzTCUU9EEKFnLmItDIx+R8oO+Cct9CwQ=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=YUJa715cNoXQgFOI3gXS2T7vP3HlDlt8WMcST6kV0gi+sGY4EneieMUa6eab6+Btf/GBF1HjaO3FeNQm7RCJtpdNSKivStLTPHjc+m97NTMg9uIGlu60/j1/kjwQF4zrDNvQ79y0uT1B7eB1X9tzHCoGxOXptD4bjsijIOUsroc= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=none (p=none dis=none) header.from=bgdev.pl; spf=none smtp.mailfrom=bgdev.pl; dkim=pass (2048-bit key) header.d=bgdev-pl.20230601.gappssmtp.com header.i=@bgdev-pl.20230601.gappssmtp.com header.b=nV/E1HNy; arc=none smtp.client-ip=209.85.128.44 Authentication-Results: smtp.subspace.kernel.org; dmarc=none (p=none dis=none) header.from=bgdev.pl Authentication-Results: smtp.subspace.kernel.org; spf=none smtp.mailfrom=bgdev.pl Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=bgdev-pl.20230601.gappssmtp.com header.i=@bgdev-pl.20230601.gappssmtp.com header.b="nV/E1HNy" Received: by mail-wm1-f44.google.com with SMTP id 5b1f17b1804b1-46b7bf21fceso36749165e9.3 for ; Wed, 24 Sep 2025 07:52:00 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=bgdev-pl.20230601.gappssmtp.com; s=20230601; t=1758725519; x=1759330319; darn=vger.kernel.org; h=cc:to:in-reply-to:references:message-id:content-transfer-encoding :mime-version:subject:date:from:from:to:cc:subject:date:message-id :reply-to; bh=zhDMW9EyWA9awJNXX9Q3cXommnoch0fAiufj04SUcx0=; b=nV/E1HNyV+9QN7xEVB5QfDKrjBv/H4MFWv88Wqrt+kquUk/2YqkG7g79aCYpyW9FK4 s5KrBrYL48LPPP4XaBevW4C/aiTY4znvn5ymgvd+gDtz4B6K8bWVYicqK64kWRaHTIUG EzlOoJ1cX7aMkAgR1phQfeIn3nsUrVkdKpkxoyigoo9O6rx2nnkUmOD5I0DK+LEpajMr K+XT1iZhTrKmISOV5V51LoGUuKTSfAmWyk7Gtao8uvgXOArgD8ZO651Tfec7hy47JT5H KnsTVh99zFFWcI0JNKEeaa4YAsO4xE+V33xwQLxckJsLjwTXNVEGJgHtyJXAkhDp+RvD y1UQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1758725519; x=1759330319; h=cc:to:in-reply-to:references:message-id:content-transfer-encoding :mime-version:subject:date:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=zhDMW9EyWA9awJNXX9Q3cXommnoch0fAiufj04SUcx0=; b=BLiLXRplOyg8/Ix8V5D6d7C3AdtIX9+mFBwZWbukZISx1/WRfSaN65znBk7g8H9dUm lablXPYcCSBJ9e2E5/Oz8R9cL4Cc0exHPkS3YVT6SJzqMArHhRvt1ypGO9x0jtoBSzNV VjXGS+oZ6Eim0oKDKdnOOH7laKuMvFi05nsK9V9/k0Weg+1N9fXWTz/EIzq7pBCHV1Se dP2pZjVWNFakCaQpSPVfJaB6/tPChsrTcDeEslpCtUKDe8xaLmUTau2+oEumByvz43AU QU5gpY6XoqBWDh4Farh0HUh3H7LmwWXzfnohNcXLquAtNZi1WqCMkGrfj9gsqeMwXTcF ZdyA== X-Forwarded-Encrypted: i=1; AJvYcCVm53meeAVGfidoE6ewiBTYbGqJXMlh9W8/x2dNIkIgxayg2S0Km09JXVWhC13Z4f13sOrk/K9qM1Gqndk=@vger.kernel.org X-Gm-Message-State: AOJu0Yy0GBnRTmeJ3N3Ox7XQqOyi8gFNHKMxj+wk0zX8DFNRTKv+pzRK mshKWU3dauv7gFelIy3wCJvcuLaDBopoxqwg4U+D8NBnIYCrzKIR05YSKkW0Vcky1u4= X-Gm-Gg: ASbGncsJDpdtO6HfIe7UuZ26cdk9sWDWxPjzFtB+VswwudX8tWXBr50fOekf+OljWBz g8m2q0yqSbUUEtP8JKpjscSTMdzLP6cgmI9XEJY6h0+p8yiMJt2yMH+C6i4oklcSGk78JEwZSEA s+fkGqd0AQgv16N2itdEaXn4YNDJLdEUMp/u25qPGTcmTTy3CByjfgGPXNLAlwjihjWJPA9vD+D 6B4LT2kp1LhVRFcGnXufIqjaHwD9mjTxrt6rNqKdv2fUG+IHfWPmGpBTKBFsSxf/aRTzEpr46xW ZlL4dp0Jp8zdHH5nnZUBrIzVLzqmO+iYqJgNmMfLKthbPV9IXDsYwJ0MS1XpiKvXz8Xel8spin6 bmxiaP0qHSQ+aQgovUA== X-Google-Smtp-Source: AGHT+IEXQ1OsqbaopW/81AV01FMskOhevY3liqHQ+TaZzWyXAp5VdKtAaaFJhzum2Q2RFl6zG/ksTg== X-Received: by 2002:a05:600c:c168:b0:45d:f897:fbe1 with SMTP id 5b1f17b1804b1-46e32a0de18mr1279345e9.32.1758725518644; Wed, 24 Sep 2025 07:51:58 -0700 (PDT) Received: from [127.0.1.1] ([2a01:cb1d:dc:7e00:1729:c9b6:7a46:b4a3]) by smtp.gmail.com with ESMTPSA id ffacd0b85a97d-3ee0fbc7188sm29514750f8f.37.2025.09.24.07.51.56 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 24 Sep 2025 07:51:57 -0700 (PDT) From: Bartosz Golaszewski Date: Wed, 24 Sep 2025 16:51:31 +0200 Subject: [PATCH RFC 3/9] gpiolib: define GPIOD_FLAG_SHARED Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Message-Id: <20250924-gpio-shared-v1-3-775e7efeb1a3@linaro.org> References: <20250924-gpio-shared-v1-0-775e7efeb1a3@linaro.org> In-Reply-To: <20250924-gpio-shared-v1-0-775e7efeb1a3@linaro.org> To: Kees Cook , Mika Westerberg , Dmitry Torokhov , Andrew Morton , Linus Walleij , Manivannan Sadhasivam , Rob Herring , Krzysztof Kozlowski , Conor Dooley , Saravana Kannan , Greg Kroah-Hartman , Andy Shevchenko , Bartosz Golaszewski , Catalin Marinas , Will Deacon , Srinivas Kandagatla , Liam Girdwood , Mark Brown , Jaroslav Kysela , Takashi Iwai Cc: linux-hardening@vger.kernel.org, linux-kernel@vger.kernel.org, linux-gpio@vger.kernel.org, linux-arm-kernel@lists.infradead.org, linux-sound@vger.kernel.org, linux-arm-msm@vger.kernel.org, Bartosz Golaszewski X-Mailer: b4 0.14.2 X-Developer-Signature: v=1; a=openpgp-sha256; l=1034; i=bartosz.golaszewski@linaro.org; h=from:subject:message-id; bh=der9rbuzwFrj8Ks9ulK3QjlAd3x3WVP4lOrBQ5vkuIQ=; b=owEBbQKS/ZANAwAKARGnLqAUcddyAcsmYgBo1AWF7GWhBGJxTAGF0PPNPgubeRhYpSPwz8NCv Nvi6uNAKwmJAjMEAAEKAB0WIQQWnetsC8PEYBPSx58Rpy6gFHHXcgUCaNQFhQAKCRARpy6gFHHX clM3EADgqkPo+x/ufaWkg/WHiN9hw/cvQg7FiJdhEdeFpxtrREOwOstiUn/WMlvJf2D4BMLn7cu mokj2sl9AHpKriv5ymzg4FA1FGhJEgjkK46mjC6T56uk4Lj9yapACQkatEbVat7XhRM8PnBgluX Jc+89aNvU/Dx088tAolt+UYFAl+45zfiOJEARt1xuEWwW8P/26l93XIE+bDy0qu9fGkKuWiRiec 5PdwrLSNmbfVKAra7sRgOFFBewIJM2rhf9J34K74Y3g4fM9WjzeTKconSAaEHPSkgUzxHn2Q8Bo sSz2uatngoMnPxxCaiAuGawKLv90e+HbbLng9dghn5mD9Espf42WF6cqI5EJ1kbl76L1Xv4oiue 4RnSq6pmGN3nL+LQg99+Yv2BmrBcQsjFh5vIuLyKyCGI7YLSssw+V5trZHExBH3knl1QCTqHCNH V3CU9z91FC4t5KeEimKB2XzTMj6XkCOI5YUN3iau8Od1M16+qMysica7cKJ6L+gPMKCrgkLVfqP DV6Y3x/EvuCr1EbBd2jXOdBJ0vxxBXrwn4+N1KFQR3AyEkhgar155iTpZRzVjehN0VABnc/eJCp sRS11jZ1qiNgb7iCtv05Cc3QFmyId9CcL8ck/LYyTKXH2HqwC9kuIWvmrc27II/8qMFiGJZM5tT G4vQ94hkIbTiDFw== X-Developer-Key: i=bartosz.golaszewski@linaro.org; a=openpgp; fpr=169DEB6C0BC3C46013D2C79F11A72EA01471D772 From: Bartosz Golaszewski Define a new GPIO descriptor flag for marking pins that are shared by multiple consumer. This flag will be used in several places so we need to do it in advance and separately from other changes. Signed-off-by: Bartosz Golaszewski --- drivers/gpio/gpiolib.h | 1 + 1 file changed, 1 insertion(+) diff --git a/drivers/gpio/gpiolib.h b/drivers/gpio/gpiolib.h index 2a003a7311e7ac5beeaa1c947d921149ad991acf..09ac92ed0853f2ff0013d1b16a5= dd082c9fd162e 100644 --- a/drivers/gpio/gpiolib.h +++ b/drivers/gpio/gpiolib.h @@ -204,6 +204,7 @@ struct gpio_desc { #define GPIOD_FLAG_EDGE_FALLING 17 /* GPIO CDEV detects falling edge even= ts */ #define GPIOD_FLAG_EVENT_CLOCK_REALTIME 18 /* GPIO CDEV reports REALTIME t= imestamps in events */ #define GPIOD_FLAG_EVENT_CLOCK_HTE 19 /* GPIO CDEV reports hardware timest= amps in events */ +#define GPIOD_FLAG_SHARED 20 /* GPIO is shared by multiple consumers */ =20 /* Connection label */ struct gpio_desc_label __rcu *label; --=20 2.48.1 From nobody Thu Oct 2 00:46:10 2025 Received: from mail-wr1-f43.google.com (mail-wr1-f43.google.com [209.85.221.43]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 7D44030F549 for ; Wed, 24 Sep 2025 14:52:02 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.221.43 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1758725525; cv=none; b=E3FKw0m+Q6WtJiXBeyRyShzICzksPIToKgqmbpp4QK0VqwTTrBHQDOqO4rkN+Rb0ZbG8+QJncm+e9uNLOgnpLTI2eY/MIPDtf/ol9qJnFIsBcbNHcWRHX4en9zTcdFkGQeDUnjOZ1RU60Rkrme5pNrbKDcebAeo/sfFChkgn9pI= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1758725525; c=relaxed/simple; bh=4za0Ya7S++NLiJanWlCxBlaG3wVI9v7d0CmK8ibmrDk=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=sBmNLEbuGN3Sy9E5z9p8QFxlfb2lYDdyMQFVTdQMdJ29b52X+AAUEb7QUDEceTkYYyLJtf0hmUm2L2srX1QUfaW7lSIEt7kDgr8LftISIgaRH1eOUZNBsr+tnqJu64mjrp6s9z+yv3Buobe8zeNXRRKHloSFTOz9KmfK/tLVakQ= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=none (p=none dis=none) header.from=bgdev.pl; spf=none smtp.mailfrom=bgdev.pl; dkim=pass (2048-bit key) header.d=bgdev-pl.20230601.gappssmtp.com header.i=@bgdev-pl.20230601.gappssmtp.com header.b=YR9oMQfo; arc=none smtp.client-ip=209.85.221.43 Authentication-Results: smtp.subspace.kernel.org; dmarc=none (p=none dis=none) header.from=bgdev.pl Authentication-Results: smtp.subspace.kernel.org; spf=none smtp.mailfrom=bgdev.pl Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=bgdev-pl.20230601.gappssmtp.com header.i=@bgdev-pl.20230601.gappssmtp.com header.b="YR9oMQfo" Received: by mail-wr1-f43.google.com with SMTP id ffacd0b85a97d-3ee13baf2e1so5210478f8f.3 for ; Wed, 24 Sep 2025 07:52:02 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=bgdev-pl.20230601.gappssmtp.com; s=20230601; t=1758725521; x=1759330321; darn=vger.kernel.org; h=cc:to:in-reply-to:references:message-id:content-transfer-encoding :mime-version:subject:date:from:from:to:cc:subject:date:message-id :reply-to; bh=PFgRf86YKrXkrP+wDE43FjexKvyhBWcztrfITVEs86o=; b=YR9oMQfoeyWXRi2rIaK/tyQyEvnTLoPkhiTBGAbrgFDugI6prDZVTIxmllEFHmedJm Ae+ii7GvloJzRE5hKUo/r4ZN8NXA9c9FMQXrqvsdD/SPooEIPEs9rbUHsmEgebKX7Q4f fMfWd1QCF0E+KaKX5hr7QLRqa+mEdlRl2losmF6iURNy2TeYpsRdQ74pXlYyWIvbdima ZAhPXEkrhEKPguvla9+rRUF/FO51tJxw79tgbFca/PyfVAFk/jXe++wqmXioZZgdBwFQ 8EHvEhgKNXkqBzeYhwOE0dt5xO5ibzcSgzMeorCcyjqHfuCx4Iyxu50IL9/GfqequAEc 89iA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1758725521; x=1759330321; h=cc:to:in-reply-to:references:message-id:content-transfer-encoding :mime-version:subject:date:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=PFgRf86YKrXkrP+wDE43FjexKvyhBWcztrfITVEs86o=; b=dFbj2DlyUNb3yo6ajE++EY87wdwEBofTUts5KnjkA5JXV0JjuhuzeKlCS3z7AC9/1V H1xShtNZi0Bjedig6L6CJgI1r2aH80s5WC3k5Hfqq1zxKAwsNTibzN80zS6jh3fju4Qg a7QXEk0h2dWVF/AkDMEZgyc2dmkjMwTkmAywR5LDwVtxIAaqeTmHmnZD7SMoFhXED7RB G/UrpjnLV7WuJYbDo2WeGUNlgiLpw5jEzwaHwCWE1XD9Kv89uoqeOB2u65EH/+c3/EaC 05085RFZ2rZWfuaK0JFzf3D5hAFhugZiRVHMVIDxZWECMNiNaATjalAsjvsmBR4X2Rnr /Jig== X-Forwarded-Encrypted: i=1; AJvYcCXFYITjwtneEKrs7FLXfawpjxxwmrP3eerMkksV6kH44xGMhBJvYVwoGWciDnYtCQXuR5vDCzQUw0VCz6U=@vger.kernel.org X-Gm-Message-State: AOJu0Yz+uV9ZKwO3QDVnif+ZyiuPg4GueCGvfWo39+G1DA1HmGe8R4wS tbyGcb37Oxs8npC+u7XWof40Nw0y73be1iDZEJMqjjOK4LUrBTUoyfkJF9MosElQq58= X-Gm-Gg: ASbGncu16+3OjFddB1VuVH54+MaNoff+3UdX5azd0BCpaCBFOLGA7jsIRjliFvSoYAl JPi0bksZsifMc9v/5sjdZ2767dBpowGw+TwVho5ska6G//Osmz7ua0Z8Z+7Pm7b4Ze+KGTK4vn4 sCIe/vCg5fvCOrg7q+BNhGgjYXKxZedxAlhb3aAh1KdunwI7iXa4q8bpgEkRHFgrpBtmsqdcmF7 RJ8WfiIaHYIZfIG+JtKEBYKf//AhtepleQnSfprUAND/j6FKjKtp/GJn3iUNeVa3NCauRigVpox XKwafWjhn+3jV+ytkzgAQmljGirv3cQBTiKXgZINVzfDXe3KVdak2mtdUY/gkaAWnLfXNGejJtT vz5EYK1B9qDusMMe0mA== X-Google-Smtp-Source: AGHT+IGv2HXUkbE/sLaSIzRqiTyAPKTJcchAXbsyOlvbPTIxZpQoQsCdK0sQG1mCkOaBbD29+ycKLw== X-Received: by 2002:a05:6000:40c8:b0:3f2:b86a:5356 with SMTP id ffacd0b85a97d-40e468e7286mr258911f8f.15.1758725520672; Wed, 24 Sep 2025 07:52:00 -0700 (PDT) Received: from [127.0.1.1] ([2a01:cb1d:dc:7e00:1729:c9b6:7a46:b4a3]) by smtp.gmail.com with ESMTPSA id ffacd0b85a97d-3ee0fbc7188sm29514750f8f.37.2025.09.24.07.51.58 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 24 Sep 2025 07:51:59 -0700 (PDT) From: Bartosz Golaszewski Date: Wed, 24 Sep 2025 16:51:32 +0200 Subject: [PATCH RFC 4/9] gpiolib: implement low-level, shared GPIO support Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Message-Id: <20250924-gpio-shared-v1-4-775e7efeb1a3@linaro.org> References: <20250924-gpio-shared-v1-0-775e7efeb1a3@linaro.org> In-Reply-To: <20250924-gpio-shared-v1-0-775e7efeb1a3@linaro.org> To: Kees Cook , Mika Westerberg , Dmitry Torokhov , Andrew Morton , Linus Walleij , Manivannan Sadhasivam , Rob Herring , Krzysztof Kozlowski , Conor Dooley , Saravana Kannan , Greg Kroah-Hartman , Andy Shevchenko , Bartosz Golaszewski , Catalin Marinas , Will Deacon , Srinivas Kandagatla , Liam Girdwood , Mark Brown , Jaroslav Kysela , Takashi Iwai Cc: linux-hardening@vger.kernel.org, linux-kernel@vger.kernel.org, linux-gpio@vger.kernel.org, linux-arm-kernel@lists.infradead.org, linux-sound@vger.kernel.org, linux-arm-msm@vger.kernel.org, Bartosz Golaszewski X-Mailer: b4 0.14.2 X-Developer-Signature: v=1; a=openpgp-sha256; l=17525; i=bartosz.golaszewski@linaro.org; h=from:subject:message-id; bh=vCkuB+L8OAyt85xbWNm/rEUGTyXD5rscBTub35QBrYA=; b=owEBbQKS/ZANAwAKARGnLqAUcddyAcsmYgBo1AWFW9Z9P5QM7D+nS/nByTaAgcvUAL6Om2GZw QXX3EVZ8S+JAjMEAAEKAB0WIQQWnetsC8PEYBPSx58Rpy6gFHHXcgUCaNQFhQAKCRARpy6gFHHX ctP6EACV7Q9voSBIDBzO6tdwHCt/iaaMMeNweJy96jWMS4qc3/y8A3Bs0unygX0yqt6H6RXJ/EM vYotNRotrQQ1HTBtrU8KEdhX97Ft+XL/wVgMubC5VqPJjCJ4jMXn8WkAXXiaKdgnMFKM2pwZWrx gddUtjfMemct5dp1o7iudLJz/PB8bwKPhVjHim3xjsG0NJmcCE4vzBfF/B2PGHt45s0hStEc/8d tKcJkE/e6pZHybQM9/j38GmEAxkKY3fm1sKWTZSVgDi+MEgneFRh6o0pE+hiG+CiYnvRgGF2HAT gaEHisjB8TvIAWX8Kof7Ryeze7KJqIq/L1OYmQ3jLPqulB4oTY4KEKCFyTSW7oVnvXWEqfe2v/L sXCdXr0IAtxsHQ3ibjcEeeFbhNs7FUNzmB48ErAsEalFBTmIkqTEkpp27O7RvqPmaHx3HQywrJf l4lR1+X/J6hfZ6Mlw35VYvuiw3Kmulz+D/rsFAjfTHS0pqL48rkXAI8BjFZf4/ZlTkoR9AFUAcu VUQsEn+i4U5aw4oNi5RocsSxVmH77JtwBFGMts89IwZzYwRTmQHnPYVA9v5U2j2gYQ6pjQym+pG WAcqART8Vl5lF/h+Cfm+xsVt8A5Y4FRt4sTMfH7d+z0YN7w8HGBxXIzbb8RXkiPsVyfkoSV2Xv3 IDJ4bnznrSBHlOg== X-Developer-Key: i=bartosz.golaszewski@linaro.org; a=openpgp; fpr=169DEB6C0BC3C46013D2C79F11A72EA01471D772 From: Bartosz Golaszewski This module scans the device tree (for now only OF nodes are supported but care is taken to make other fwnode implementations easy to integrate) and determines which GPIO lines are shared by multiple users. It stores that information in memory. When the GPIO chip exposing shared lines is registered, the shared GPIO descriptors it exposes are marked as shared and virtual "proxy" devices that mediate access to the shared lines are created. When a consumer of a shared GPIO looks it up, its fwnode lookup is redirected to a just-in-time machine lookup that points to this proxy device. This code can be compiled out on platforms which don't use shared GPIOs. Signed-off-by: Bartosz Golaszewski --- drivers/gpio/Kconfig | 8 + drivers/gpio/Makefile | 1 + drivers/gpio/gpiolib-shared.c | 481 ++++++++++++++++++++++++++++++++++++++= ++++ drivers/gpio/gpiolib-shared.h | 71 +++++++ 4 files changed, 561 insertions(+) diff --git a/drivers/gpio/Kconfig b/drivers/gpio/Kconfig index 7ee3afbc2b05da4d7470e609a0311ecc38727b00..679a7385a9776eef96a86ca4f42= 9ee83ac939362 100644 --- a/drivers/gpio/Kconfig +++ b/drivers/gpio/Kconfig @@ -6,6 +6,9 @@ config GPIOLIB_LEGACY def_bool y =20 +config HAVE_SHARED_GPIOS + bool + menuconfig GPIOLIB bool "GPIO Support" help @@ -42,6 +45,11 @@ config GPIOLIB_IRQCHIP select IRQ_DOMAIN bool =20 +config GPIO_SHARED + def_bool y + depends on HAVE_SHARED_GPIOS || COMPILE_TEST + select AUXILIARY_BUS + config OF_GPIO_MM_GPIOCHIP bool help diff --git a/drivers/gpio/Makefile b/drivers/gpio/Makefile index ec296fa14bfdb360c27b4578826354762f01f074..f702f7e27e5b4017e7eab3019da= e4ec912d534f8 100644 --- a/drivers/gpio/Makefile +++ b/drivers/gpio/Makefile @@ -12,6 +12,7 @@ obj-$(CONFIG_GPIO_SYSFS) +=3D gpiolib-sysfs.o obj-$(CONFIG_GPIO_ACPI) +=3D gpiolib-acpi.o gpiolib-acpi-y :=3D gpiolib-acpi-core.o gpiolib-acpi-quirks.o obj-$(CONFIG_GPIOLIB) +=3D gpiolib-swnode.o +obj-$(CONFIG_GPIO_SHARED) +=3D gpiolib-shared.o =20 # Device drivers. Generally keep list sorted alphabetically obj-$(CONFIG_GPIO_REGMAP) +=3D gpio-regmap.o diff --git a/drivers/gpio/gpiolib-shared.c b/drivers/gpio/gpiolib-shared.c new file mode 100644 index 0000000000000000000000000000000000000000..97c16a73bb207bdf1728adda871= 61c1522415a67 --- /dev/null +++ b/drivers/gpio/gpiolib-shared.c @@ -0,0 +1,481 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* + * Copyright (C) 2025 Linaro Ltd. + */ + +#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "gpiolib.h" +#include "gpiolib-shared.h" + +/* Represents a single reference to a GPIO pin. */ +struct gpio_shared_ref { + struct list_head list; + /* Firmware node associated with this GPIO's consumer. */ + struct fwnode_handle *fwnode; + /* GPIO flags this consumer uses for the request. */ + enum gpiod_flags flags; + char *con_id; + int dev_id; + struct auxiliary_device adev; + struct gpiod_lookup_table *lookup; +}; + +/* Represents a single GPIO pin. */ +struct gpio_shared_entry { + struct list_head list; + /* Firmware node associated with the GPIO controller. */ + struct fwnode_handle *fwnode; + /* Hardware offset of the GPIO within its chip. */ + unsigned int offset; + /* Index in the property value array. */ + size_t index; + struct gpio_shared_desc *shared_desc; + struct kref ref; + struct list_head refs; +}; + +static LIST_HEAD(gpio_shared_list); +static DEFINE_MUTEX(gpio_shared_lock); +static DEFINE_IDA(gpio_shared_ida); + +static struct gpio_shared_entry * +gpio_shared_find_entry(struct fwnode_handle *controller_node, + unsigned int offset) +{ + struct gpio_shared_entry *entry; + + list_for_each_entry(entry, &gpio_shared_list, list) { + if (entry->fwnode =3D=3D controller_node && entry->offset =3D=3D offset) + return entry; + } + + return NULL; +} + +#if IS_ENABLED(CONFIG_OF) +static int gpio_shared_of_traverse(struct device_node *curr) +{ + static const char *const suffixes[] =3D { "-gpios", "-gpio", NULL }; + + struct gpio_shared_entry *entry; + size_t con_id_len, suffix_len; + struct fwnode_handle *fwnode; + struct gpio_shared_ref *ref; + struct of_phandle_args args; + const char *const *suffix; + struct property *prop; + unsigned int offset; + int ret, count, i; + + for_each_property_of_node(curr, prop) { + /* + * The standard name for a GPIO property is "foo-gpios" + * or "foo-gpio". Some bindings also use "gpios" or "gpio". + * There are some legacy device-trees which have a different + * naming convention and for which we have rename quirks in + * place in gpiolib-of.c. I don't think any of them require + * support for shared GPIOs so for now let's just ignore + * them. We can always just export the quirk list and + * iterate over it here. + */ + if (!strends(prop->name, "-gpios") && + !strends(prop->name, "-gpio") && + strcmp(prop->name, "gpios") !=3D 0 && + strcmp(prop->name, "gpio") !=3D 0) + continue; + + count =3D of_count_phandle_with_args(curr, prop->name, + "#gpio-cells"); + if (count <=3D 0) + continue; + + for (i =3D 0; i < count; i++) { + struct device_node *np __free(device_node) =3D NULL; + + ret =3D of_parse_phandle_with_args(curr, prop->name, + "#gpio-cells", i, + &args); + if (ret) + continue; + + np =3D args.np; + + if (!of_property_present(np, "gpio-controller")) + continue; + + /* + * We support 1, 2 and 3 cell GPIO bindings in the + * kernel currently. There's only one old MIPS dts that + * has a one-cell binding but there's no associated + * consumer so it may as well be an error. There don't + * seem to be any 3-cell users of non-exclusive GPIOs, + * so we can skip this as well. Let's occupy ourselves + * with the predominant 2-cell binding with the first + * cell indicating the hardware offset of the GPIO and + * the second defining the GPIO flags of the request. + */ + if (args.args_count !=3D 2) + continue; + + fwnode =3D of_fwnode_handle(args.np); + offset =3D args.args[0]; + + entry =3D gpio_shared_find_entry(fwnode, offset); + if (!entry) { + entry =3D kzalloc(sizeof(*entry), GFP_KERNEL); + if (!entry) + return -ENOMEM; + + entry->fwnode =3D fwnode_handle_get(fwnode); + entry->offset =3D offset; + entry->index =3D count; + INIT_LIST_HEAD(&entry->refs); + + list_add_tail(&entry->list, &gpio_shared_list); + } + + ref =3D kzalloc(sizeof(*ref), GFP_KERNEL); + if (!ref) + return -ENOMEM; + + ref->fwnode =3D fwnode_handle_get(of_fwnode_handle(curr)); + ref->flags =3D args.args[1]; + + for (suffix =3D suffixes; *suffix; suffix++) { + if (!strends(prop->name, *suffix)) + continue; + + ref->con_id =3D kstrdup(prop->name, GFP_KERNEL); + if (!ref->con_id) + return -ENOMEM; + + ref->dev_id =3D ida_alloc(&gpio_shared_ida, GFP_KERNEL); + if (ref->dev_id < 0) { + kfree(ref->con_id); + return -ENOMEM; + } + + con_id_len =3D strlen(ref->con_id); + suffix_len =3D strlen(*suffix); + + ref->con_id[con_id_len - suffix_len] =3D '\0'; + } + + if (!list_empty(&entry->refs)) + pr_debug("GPIO %u at %s is shared by multiple firmware nodes\n", + entry->offset, fwnode_get_name(entry->fwnode)); + + list_add_tail(&ref->list, &entry->refs); + } + } + + for_each_child_of_node_scoped(curr, child) { + ret =3D gpio_shared_of_traverse(child); + if (ret) + return ret; + } + + return 0; +} + +static int gpio_shared_of_scan(void) +{ + return gpio_shared_of_traverse(of_root); +} +#else +static int gpio_shared_of_scan(void) +{ + return 0; +} +#endif /* CONFIG_OF */ + +static int gpio_shared_make_adev(struct gpio_device *gdev, + struct gpio_shared_ref *ref) +{ + struct auxiliary_device *adev =3D &ref->adev; + int ret; + + lockdep_assert_held(&gpio_shared_lock); + + memset(adev, 0, sizeof(*adev)); + + adev->id =3D ref->dev_id; + adev->name =3D "proxy"; + adev->dev.parent =3D gdev->dev.parent; + /* No need to dev->release() anything. */ + + ret =3D auxiliary_device_init(adev); + if (ret) + return ret; + + ret =3D auxiliary_device_add(adev); + if (ret) { + auxiliary_device_uninit(adev); + return ret; + } + + pr_debug("Created an auxiliary GPIO proxy %s for GPIO device %s\n", + dev_name(&adev->dev), gpio_device_get_label(gdev)); + + return 0; +} + +int gpio_shared_add_proxy_lookup(struct device *consumer, unsigned long lf= lags) +{ + const char *dev_id =3D dev_name(consumer); + struct gpio_shared_entry *entry; + struct gpio_shared_ref *ref; + + struct gpiod_lookup_table *lookup __free(kfree) =3D + kzalloc(struct_size(lookup, table, 2), GFP_KERNEL); + if (!lookup) + return -ENOMEM; + + guard(mutex)(&gpio_shared_lock); + + list_for_each_entry(entry, &gpio_shared_list, list) { + list_for_each_entry(ref, &entry->refs, list) { + if (!device_match_fwnode(consumer, ref->fwnode)) + continue; + + /* We've already done that on a previous request. */ + if (ref->lookup) + return 0; + + char *key __free(kfree) =3D + kasprintf(GFP_KERNEL, + KBUILD_MODNAME ".proxy.%u", + ref->adev.id); + if (!key) + return -ENOMEM; + + pr_debug("Adding machine lookup entry for a shared GPIO for consumer %s= , with key '%s' and con_id '%s'\n", + dev_id, key, ref->con_id); + + lookup->dev_id =3D dev_id; + lookup->table[0] =3D GPIO_LOOKUP(no_free_ptr(key), 0, + ref->con_id, lflags); + + gpiod_add_lookup_table(no_free_ptr(lookup)); + + return 0; + } + } + + /* We warn here because this can only happen if the programmer borked. */ + WARN_ON(1); + return -ENOENT; +} + +static void gpio_shared_remove_adev(struct auxiliary_device *adev) +{ + lockdep_assert_held(&gpio_shared_lock); + + auxiliary_device_uninit(adev); + auxiliary_device_delete(adev); +} + +int gpio_device_setup_shared(struct gpio_device *gdev) +{ + struct gpio_shared_entry *entry; + struct gpio_shared_ref *ref; + unsigned long *flags; + int ret; + + guard(mutex)(&gpio_shared_lock); + + list_for_each_entry(entry, &gpio_shared_list, list) { + if (!device_match_fwnode(&gdev->dev, entry->fwnode)) + continue; + + if (list_count_nodes(&entry->refs) <=3D 1) + continue; + + flags =3D &gdev->descs[entry->offset].flags; + + set_bit(GPIOD_FLAG_SHARED, flags); + /* + * Shared GPIOs are not requested via the normal path. Make + * them inaccessible to anyone even before we register the + * chip. + */ + set_bit(GPIOD_FLAG_REQUESTED, flags); + + pr_debug("GPIO %u owned by %s is shared by multiple consumers\n", + entry->offset, gpio_device_get_label(gdev)); + + list_for_each_entry(ref, &entry->refs, list) { + pr_debug("Setting up a shared GPIO entry for %s\n", + fwnode_get_name(ref->fwnode)); + + ret =3D gpio_shared_make_adev(gdev, ref); + if (ret) + return ret; + } + } + + return 0; +} + +void gpio_device_teardown_shared(struct gpio_device *gdev) +{ + struct gpio_shared_entry *entry; + struct gpio_shared_ref *ref; + + guard(mutex)(&gpio_shared_lock); + + list_for_each_entry(entry, &gpio_shared_list, list) { + if (!device_match_fwnode(&gdev->dev, entry->fwnode)) + continue; + + list_for_each_entry(ref, &entry->refs, list) { + gpiod_remove_lookup_table(ref->lookup); + kfree(ref->lookup->table[0].key); + kfree(ref->lookup); + ref->lookup =3D NULL; + gpio_shared_remove_adev(&ref->adev); + } + } +} + +static void gpio_shared_release(struct kref *kref) +{ + struct gpio_shared_entry *entry =3D + container_of(kref, struct gpio_shared_entry, ref); + struct gpio_shared_desc *shared_desc =3D entry->shared_desc; + + guard(mutex)(&gpio_shared_lock); + + gpio_device_put(shared_desc->desc->gdev); + if (shared_desc->can_sleep) + mutex_destroy(&shared_desc->mutex); + kfree(shared_desc); + entry->shared_desc =3D NULL; +} + +static void gpiod_shared_put(void *data) +{ + struct gpio_shared_entry *entry =3D data; + + lockdep_assert_not_held(&gpio_shared_lock); + + kref_put(&entry->ref, gpio_shared_release); +} + +struct gpio_shared_desc *devm_gpiod_shared_get(struct device *dev) +{ + struct auxiliary_device *adev =3D to_auxiliary_dev(dev); + struct gpio_shared_desc *shared_desc; + struct gpio_shared_entry *entry; + struct gpio_shared_ref *ref; + struct gpio_device *gdev; + int ret; + + scoped_guard(mutex, &gpio_shared_lock) { + list_for_each_entry(entry, &gpio_shared_list, list) { + list_for_each_entry(ref, &entry->refs, list) { + if (adev !=3D &ref->adev) + continue; + + if (entry->shared_desc) { + kref_get(&entry->ref); + shared_desc =3D entry->shared_desc; + break; + } + + shared_desc =3D kzalloc(sizeof(*shared_desc), GFP_KERNEL); + if (!shared_desc) + return ERR_PTR(-ENOMEM); + + gdev =3D gpio_device_find_by_fwnode(entry->fwnode); + if (!gdev) { + kfree(shared_desc); + return ERR_PTR(-EPROBE_DEFER); + } + + shared_desc->desc =3D &gdev->descs[entry->offset]; + shared_desc->can_sleep =3D gpiod_cansleep(shared_desc->desc); + if (shared_desc->can_sleep) + mutex_init(&shared_desc->mutex); + else + spin_lock_init(&shared_desc->spinlock); + + kref_init(&entry->ref); + entry->shared_desc =3D shared_desc; + + pr_debug("Device %s acquired a reference to the shared GPIO %u owned b= y %s\n", + dev_name(dev), desc_to_gpio(shared_desc->desc), + gpio_device_get_label(gdev)); + break; + } + } + } + + ret =3D devm_add_action_or_reset(dev, gpiod_shared_put, entry); + if (ret) + return ERR_PTR(ret); + + return shared_desc; +} +EXPORT_SYMBOL_GPL(devm_gpiod_shared_get); + +/* + * This is only called if gpio_shared_init() fails so it's in fact __init = and + * not __exit. + */ +static void __init gpio_shared_teardown(void) +{ + struct gpio_shared_entry *entry, *epos; + struct gpio_shared_ref *ref, *rpos; + + list_for_each_entry_safe(entry, epos, &gpio_shared_list, list) { + list_for_each_entry_safe(ref, rpos, &entry->refs, list) { + list_del(&ref->list); + kfree(ref->con_id); + ida_free(&gpio_shared_ida, ref->dev_id); + fwnode_handle_put(ref->fwnode); + kfree(ref); + } + + list_del(&entry->list); + fwnode_handle_put(entry->fwnode); + kfree(entry); + } +} + +static int __init gpio_shared_init(void) +{ + int ret; + + /* Right now, we only support OF-based systems. */ + ret =3D gpio_shared_of_scan(); + if (ret) { + gpio_shared_teardown(); + pr_err("Failed to scan OF nodes for shared GPIOs: %d\n", ret); + return ret; + } + + pr_debug("Finished scanning firmware nodes for shared GPIOs\n"); + return 0; +} +postcore_initcall(gpio_shared_init); diff --git a/drivers/gpio/gpiolib-shared.h b/drivers/gpio/gpiolib-shared.h new file mode 100644 index 0000000000000000000000000000000000000000..667dbdff3585066b7cbe2ebe476= 725fe7d683d84 --- /dev/null +++ b/drivers/gpio/gpiolib-shared.h @@ -0,0 +1,71 @@ +/* SPDX-License-Identifier: GPL-2.0 */ + +#ifndef __LINUX_GPIO_SHARED_H +#define __LINUX_GPIO_SHARED_H + +#include +#include +#include +#include + +struct gpio_device; +struct gpio_desc; +struct device; + +#if IS_ENABLED(CONFIG_GPIO_SHARED) + +int gpio_device_setup_shared(struct gpio_device *gdev); +void gpio_device_teardown_shared(struct gpio_device *gdev); +int gpio_shared_add_proxy_lookup(struct device *consumer, unsigned long lf= lags); + +#else + +static inline int gpio_device_setup_shared(struct gpio_device *gdev) +{ + return 0; +} + +static inline void gpio_device_teardown_shared(struct gpio_device *gdev) {= } + +static inline int gpio_shared_add_proxy_lookup(struct device *consumer, + unsigned long lflags) +{ + return 0; +} + +#endif /* CONFIG_GPIO_SHARED */ + +struct gpio_shared_desc { + struct gpio_desc *desc; + bool can_sleep; + unsigned long cfg; + unsigned int usecnt; + unsigned int highcnt; + union { + struct mutex mutex; + spinlock_t spinlock; + }; +}; + +struct gpio_shared_desc *devm_gpiod_shared_get(struct device *dev); + +DEFINE_LOCK_GUARD_1(gpio_shared_desc_lock, struct gpio_shared_desc, + if (_T->lock->can_sleep) + mutex_lock(&_T->lock->mutex); + else + spin_lock_irqsave(&_T->lock->spinlock, _T->flags), + if (_T->lock->can_sleep) + mutex_unlock(&_T->lock->mutex); + else + spin_unlock_irqrestore(&_T->lock->spinlock, _T->flags), + unsigned long flags) + +static inline void gpio_shared_lockdep_assert(struct gpio_shared_desc *sha= red_desc) +{ + if (shared_desc->can_sleep) + lockdep_assert_held(&shared_desc->mutex); + else + lockdep_assert_held(&shared_desc->spinlock); +} + +#endif /* __LINUX_GPIO_SHARED_H */ --=20 2.48.1 From nobody Thu Oct 2 00:46:10 2025 Received: from mail-wr1-f48.google.com (mail-wr1-f48.google.com [209.85.221.48]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 6DBF230FC06 for ; Wed, 24 Sep 2025 14:52:04 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.221.48 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1758725527; cv=none; b=JYvOzahKR6Slf6A8Znvb+70J9lpEeUn9v414jkjmij8NpMWMJaWKql52fEkQ2vQfCQdsAvuV1YOBzl3hLyFZdArRD3rqxVxmWbpXvSz6vGUhr4wk2mOk4Hg9vbgILWLjWe9CUXCVkPosx6YuPdS4/jyzyJ7nKZDY5J6/qVPtoY0= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1758725527; c=relaxed/simple; bh=+6bUkVVp8G03JbyHHR+HPFtY9U9Xkn8bXnrMLoG9W+Q=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=Tk7nIIFhZHE5lwAF3EH+LgoudgpsuwnulgvmfYb+MQhg4DrUN8/akTlHU68PYTafR20c7rSSiY0xfQ+Uu+Ohe2aVvI12dEmcECK7nqKI2g7spGQ+JuVncZh0G+tcFhsDl/UhgthJrlfQ0pf9OlOXtKGtlSYZMDonRQkW7qwz7eY= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=none (p=none dis=none) header.from=bgdev.pl; spf=none smtp.mailfrom=bgdev.pl; dkim=pass (2048-bit key) header.d=bgdev-pl.20230601.gappssmtp.com header.i=@bgdev-pl.20230601.gappssmtp.com header.b=kHbg1+U1; arc=none smtp.client-ip=209.85.221.48 Authentication-Results: smtp.subspace.kernel.org; dmarc=none (p=none dis=none) header.from=bgdev.pl Authentication-Results: smtp.subspace.kernel.org; spf=none smtp.mailfrom=bgdev.pl Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=bgdev-pl.20230601.gappssmtp.com header.i=@bgdev-pl.20230601.gappssmtp.com header.b="kHbg1+U1" Received: by mail-wr1-f48.google.com with SMTP id ffacd0b85a97d-3ed20bdfdffso7023283f8f.2 for ; Wed, 24 Sep 2025 07:52:04 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=bgdev-pl.20230601.gappssmtp.com; s=20230601; t=1758725523; x=1759330323; darn=vger.kernel.org; h=cc:to:in-reply-to:references:message-id:content-transfer-encoding :mime-version:subject:date:from:from:to:cc:subject:date:message-id :reply-to; bh=MSgowDlzhmLR7n/hdS2kMt37iKRjtkVmdn3+P096axs=; b=kHbg1+U1DcfqpkNcUG2nu/bu6svZ141ys68TQriNMYVNKtJYx0SpUQb7LcsdZeObcc FqELeQGq9kzd/ZfuWPGITEWa0whFxM0tYAUzCuScs95HZm/gf48X5ypgKmE5oBXFfpVX ZFdKR9GpIJAKTeftlDNReu6HqvSTzFufLFIdColBGw8xg7iZewboE8z90ayGST1r1zlM fihrvv/qW2+8XkW7ZV6SF597NYK3q4ctsspUqHYnvBbwdI4Czs5RWP9i0fEOLd1bM0cj Dpe+VIh85bQ6u5/OL+uEM4K/7E+OcePlkToMsQK7REj1r6IIrUIElk+MDKdL8ga1762i F+DQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1758725523; x=1759330323; h=cc:to:in-reply-to:references:message-id:content-transfer-encoding :mime-version:subject:date:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=MSgowDlzhmLR7n/hdS2kMt37iKRjtkVmdn3+P096axs=; b=lZdExjSmC98BiwMfrC7yxWup1mi/hvF6WwA0+MgCKzvYmzDrsNHJz8bsTbep7u8mBa GAUcmkoHFtyfM+Xk3LMg1qn3q7x1lt78Rt2ptAPcgMD5uZUYsYlqqWNzHK+ZRl28yZcB U4mcvlScPfKGqkPAotrULzyg7W9TQ8COiE019w+pahfTYxyGfGjtorFpuh/dde4xAfZz gJgS/sH+GEQgJk7Gic9quiu5k6TwR5xSvi+4tTEAGN37GvjdQaIXot+wOD7abmUuMDcA Iu8FyxCjqGM/5bhpOTaBTZPLemRXpG7KxBxu9H5Q3cXMBg5vl+c667KW3l/vH+KhaEv/ B/Bw== X-Forwarded-Encrypted: i=1; AJvYcCVpfY6hYxUmJJ+GbocydwGzZmzx2RLBT+jyWGx9Ufjxg+50YMO9AiFKdRbRCLEbgdqx4W0xjNkucgecavw=@vger.kernel.org X-Gm-Message-State: AOJu0Ywo9Q/U302bOCJi2ciD+0uIuPS9R6kE367ytUcOqLjrk6j7eEgO d6rcWpj73SxboN58a1//+tP830U7fqK1toPIiQiS28ecOlMpLcFe3Y0RqvdwGRGHADE= X-Gm-Gg: ASbGncuFFYw47K1My8k44weNPWZuFqPAo6uUx3UP9Z6JmVYFMSohSywK7IZzlTlF3Dk qXx039kZgCTwsCFJGlL5qui3FxOBbPz36evs/dXrcytDsOJP5vrulTw1ai+2Npkt5igaoQo3UW0 CdXCk8gbWNah6W9XRaabSJ1jWNj7LzcsFR15UEOzkVEc8j6q9bYViwmkVX27LTtRHV2liLtsS4X mq2SfnFl2sy9Lw8zMmU07u0ZEETOfGuLoKHbw6vuR+XVLP9jvEK1VCRP4KY9BnxGj4ohdscVTpz rr3Wx04KXsCe3pb4S+AyGobZnuB22R06Og+/X2WCe7+6QWVmC4lf2k6BJr/AQTbFmxcGevmQJIk sK0BQ590pzRQ2QW2YKkjvMSPIMPvo X-Google-Smtp-Source: AGHT+IEyXrLx96T6QsIa8eF3uCo4FfQct7eHaeDlUb6PK1yPrstccT+eXxcbpNJurK4UN8hglLiDIQ== X-Received: by 2002:a05:6000:2486:b0:3ed:e1d8:bd73 with SMTP id ffacd0b85a97d-40e4d9c9330mr205855f8f.57.1758725522647; Wed, 24 Sep 2025 07:52:02 -0700 (PDT) Received: from [127.0.1.1] ([2a01:cb1d:dc:7e00:1729:c9b6:7a46:b4a3]) by smtp.gmail.com with ESMTPSA id ffacd0b85a97d-3ee0fbc7188sm29514750f8f.37.2025.09.24.07.52.00 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 24 Sep 2025 07:52:01 -0700 (PDT) From: Bartosz Golaszewski Date: Wed, 24 Sep 2025 16:51:33 +0200 Subject: [PATCH RFC 5/9] gpio: shared-proxy: implement the shared GPIO proxy driver Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Message-Id: <20250924-gpio-shared-v1-5-775e7efeb1a3@linaro.org> References: <20250924-gpio-shared-v1-0-775e7efeb1a3@linaro.org> In-Reply-To: <20250924-gpio-shared-v1-0-775e7efeb1a3@linaro.org> To: Kees Cook , Mika Westerberg , Dmitry Torokhov , Andrew Morton , Linus Walleij , Manivannan Sadhasivam , Rob Herring , Krzysztof Kozlowski , Conor Dooley , Saravana Kannan , Greg Kroah-Hartman , Andy Shevchenko , Bartosz Golaszewski , Catalin Marinas , Will Deacon , Srinivas Kandagatla , Liam Girdwood , Mark Brown , Jaroslav Kysela , Takashi Iwai Cc: linux-hardening@vger.kernel.org, linux-kernel@vger.kernel.org, linux-gpio@vger.kernel.org, linux-arm-kernel@lists.infradead.org, linux-sound@vger.kernel.org, linux-arm-msm@vger.kernel.org, Bartosz Golaszewski X-Mailer: b4 0.14.2 X-Developer-Signature: v=1; a=openpgp-sha256; l=11907; i=bartosz.golaszewski@linaro.org; h=from:subject:message-id; bh=sfRoEgGj7pFTcA+n5dZu5OkxqjXNqNa9C5JDXNfemak=; b=owEBbQKS/ZANAwAKARGnLqAUcddyAcsmYgBo1AWGpmtkXlBA5OHbVuuWQ7dGjcVco9DBJIZ8K fP8ukS/waWJAjMEAAEKAB0WIQQWnetsC8PEYBPSx58Rpy6gFHHXcgUCaNQFhgAKCRARpy6gFHHX ck0BD/98hcjOxep9HWr0VdKe/QouS7zxedAcWxWEJoMrhkgG1BLWJn535Te3HNz/Tynze+mRBL2 k8OsfoyLfQ7kuvDsMiJJYTGDNeUZzjgvRbSqlukONXP+fAbFVer7RiIu6iOpVEkd0EIH1wx9FJw xnH3SFt+Tg7TbwCsf6q3xjOrZe7iXIGFCtOn6iz3EShqRdJ678/At4IGPnN5N+pWJEInqiTHehc c1de5mkBKXtKhAnKffUxNqNOBw177wIf+Mr/q87uJP5s3NIbhSkO1x7Wgfovssk42njcuuqigBp X0pSHMEjSzmOE4arnFD80o0Q+lVUezJXnRPAmtNYN8k3v9cBQE16+RPkImcnKUBfhlO085MnYJN G8MBI+Yyr7Lr0fIrlQbRe2WnbjTvp7scVRLBM81BMN/kuTSlqHcSRAivsBzDwr0AwCHuTDrXef9 OqsEQPL9fGaOxVtNSXBiyE+yu7RdFvzvh3xWKKNDhMoOlLT0ZqQ65LwqdVDuKfibEB0d9O6ns55 77wWwBf60k++C9fUYEUmXZydRs7RRVyb7CKCQqassR1f1YUY061diwTRhyOPGVLP5EsugEpxVfN eAhuOPTQHAC+8g3a6kveR0eW2FY9wLriKQM3f1I9YY3fSgcjNnA2Fttjlm0nT1dn4I7p4OxaQwg OUq+8Fe82eMv9iA== X-Developer-Key: i=bartosz.golaszewski@linaro.org; a=openpgp; fpr=169DEB6C0BC3C46013D2C79F11A72EA01471D772 From: Bartosz Golaszewski Add a virtual GPIO proxy driver which arbitrates access to a single shared GPIO by multiple users. It works together with the core shared GPIO support from GPIOLIB and functions by acquiring a reference to a shared GPIO descriptor exposed by gpiolib-shared and making sure that the state of the GPIO stays consistent. In general: if there's only one user at the moment: allow it to do anything as if this was a normal GPIO (in essence: just propagate calls to the underlying real hardware driver). If there are more users: don't allow to change the direction set by the initial user, allow to change configuration options but warn about possible conflicts and finally: treat the output-high value as a reference counted, logical "GPIO enabled" setting, meaning: the GPIO value is set to high when the first user requests it to be high and back to low once the last user stops "voting" for high. Signed-off-by: Bartosz Golaszewski --- drivers/gpio/Kconfig | 9 ++ drivers/gpio/Makefile | 1 + drivers/gpio/gpio-shared-proxy.c | 328 +++++++++++++++++++++++++++++++++++= ++++ 3 files changed, 338 insertions(+) diff --git a/drivers/gpio/Kconfig b/drivers/gpio/Kconfig index 679a7385a9776eef96a86ca4f429ee83ac939362..de8e4febf344fc19a633cd7efe8= 412fe12166fb8 100644 --- a/drivers/gpio/Kconfig +++ b/drivers/gpio/Kconfig @@ -2025,6 +2025,15 @@ config GPIO_SIM This enables the GPIO simulator - a configfs-based GPIO testing driver. =20 +config GPIO_SHARED_PROXY + tristate "Proxy driver for non-exclusive GPIOs" + default m + depends on GPIO_SHARED || COMPILE_TEST + select AUXILIARY_BUS + help + This enables the GPIO shared proxy driver - an abstraction layer + for GPIO pins that are shared by multiple devices. + endmenu =20 menu "GPIO Debugging utilities" diff --git a/drivers/gpio/Makefile b/drivers/gpio/Makefile index f702f7e27e5b4017e7eab3019dae4ec912d534f8..d0020bc70b84f6fb9949165070c= 21725a60f47e2 100644 --- a/drivers/gpio/Makefile +++ b/drivers/gpio/Makefile @@ -160,6 +160,7 @@ obj-$(CONFIG_ARCH_SA1100) +=3D gpio-sa1100.o obj-$(CONFIG_GPIO_SAMA5D2_PIOBU) +=3D gpio-sama5d2-piobu.o obj-$(CONFIG_GPIO_SCH311X) +=3D gpio-sch311x.o obj-$(CONFIG_GPIO_SCH) +=3D gpio-sch.o +obj-$(CONFIG_GPIO_SHARED_PROXY) +=3D gpio-shared-proxy.o obj-$(CONFIG_GPIO_SIFIVE) +=3D gpio-sifive.o obj-$(CONFIG_GPIO_SIM) +=3D gpio-sim.o obj-$(CONFIG_GPIO_SIOX) +=3D gpio-siox.o diff --git a/drivers/gpio/gpio-shared-proxy.c b/drivers/gpio/gpio-shared-pr= oxy.c new file mode 100644 index 0000000000000000000000000000000000000000..804038d33a40e45c8577f278fae= a79145a91a5bd --- /dev/null +++ b/drivers/gpio/gpio-shared-proxy.c @@ -0,0 +1,328 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* + * Copyright (C) 2025 Linaro Ltd. + */ + +#include +#include +#include +#include +#include +#include + +#include "gpiolib-shared.h" + +struct gpio_shared_proxy_data { + struct gpio_chip gc; + struct gpio_shared_desc *shared_desc; + struct device *dev; + bool voted_high; +}; + +static int +gpio_shared_proxy_set_unlocked(struct gpio_shared_proxy_data *proxy, + int (*set_func)(struct gpio_desc *desc, int value), + int value) +{ + struct gpio_shared_desc *shared_desc =3D proxy->shared_desc; + struct gpio_desc *desc =3D shared_desc->desc; + int ret =3D 0; + + gpio_shared_lockdep_assert(shared_desc); + + if (value) { + /* User wants to set value to high. */ + if (proxy->voted_high) + /* Already voted for high, nothing to do. */ + goto out; + + /* Haven't voted for high yet. */ + if (!shared_desc->highcnt) { + /* + * Current value is low, need to actually set value + * to high. + */ + ret =3D set_func(desc, 1); + if (ret) + goto out; + } + + shared_desc->highcnt++; + proxy->voted_high =3D true; + + goto out; + } + + /* Desired value is low. */ + if (!proxy->voted_high) + /* We didn't vote for high, nothing to do. */ + goto out; + + /* We previously voted for high. */ + if (shared_desc->highcnt =3D=3D 1) { + /* This is the last remaining vote for high, set value to low. */ + ret =3D set_func(desc, 0); + if (ret) + goto out; + } + + shared_desc->highcnt--; + proxy->voted_high =3D false; + +out: + if (shared_desc->highcnt) + dev_dbg(proxy->dev, + "Voted for value '%s', effective value is 'high', number of votes for '= high': %u\n", + value ? "high" : "low", shared_desc->highcnt); + else + dev_dbg(proxy->dev, "Voted for value 'low', effective value is 'low'\n"); + + return ret; +} + +static int gpio_shared_proxy_request(struct gpio_chip *gc, unsigned int of= fset) +{ + struct gpio_shared_proxy_data *proxy =3D gpiochip_get_data(gc); + struct gpio_shared_desc *shared_desc =3D proxy->shared_desc; + + guard(gpio_shared_desc_lock)(shared_desc); + + proxy->shared_desc->usecnt++; + + dev_dbg(proxy->dev, "Shared GPIO requested, number of users: %u\n", + proxy->shared_desc->usecnt); + + return 0; +} + +static void gpio_shared_proxy_free(struct gpio_chip *gc, unsigned int offs= et) +{ + struct gpio_shared_proxy_data *proxy =3D gpiochip_get_data(gc); + struct gpio_shared_desc *shared_desc =3D proxy->shared_desc; + + guard(gpio_shared_desc_lock)(shared_desc); + + proxy->shared_desc->usecnt--; + + dev_dbg(proxy->dev, "Shared GPIO freed, number of users: %u\n", + proxy->shared_desc->usecnt); +} + +static int gpio_shared_proxy_set_config(struct gpio_chip *gc, + unsigned int offset, unsigned long cfg) +{ + struct gpio_shared_proxy_data *proxy =3D gpiochip_get_data(gc); + struct gpio_shared_desc *shared_desc =3D proxy->shared_desc; + struct gpio_desc *desc =3D shared_desc->desc; + int ret; + + guard(gpio_shared_desc_lock)(shared_desc); + + if (shared_desc->usecnt > 1) { + if (shared_desc->cfg !=3D cfg) { + dev_dbg(proxy->dev, + "Shared GPIO's configuration already set, accepting changes but users = may conflict!!\n"); + } else { + dev_dbg(proxy->dev, "Equal config requested, nothing to do\n"); + return 0; + } + } + + ret =3D gpiod_set_config(desc, cfg); + if (ret && ret !=3D -ENOTSUPP) + return ret; + + shared_desc->cfg =3D cfg; + return 0; +} + +static int gpio_shared_proxy_direction_input(struct gpio_chip *gc, + unsigned int offset) +{ + struct gpio_shared_proxy_data *proxy =3D gpiochip_get_data(gc); + struct gpio_shared_desc *shared_desc =3D proxy->shared_desc; + struct gpio_desc *desc =3D shared_desc->desc; + int dir; + + guard(gpio_shared_desc_lock)(shared_desc); + + if (shared_desc->usecnt =3D=3D 1) { + dev_dbg(proxy->dev, + "Only one user of this shared GPIO, allowing to set direction to input\= n"); + + return gpiod_direction_input(desc); + } + + dir =3D gpiod_get_direction(desc); + if (dir < 0) + return dir; + + if (dir =3D=3D GPIO_LINE_DIRECTION_OUT) { + dev_dbg(proxy->dev, + "Shared GPIO's direction already set to output, refusing to change\n"); + return -EPERM; + } + + return 0; +} + +static int gpio_shared_proxy_direction_output(struct gpio_chip *gc, + unsigned int offset, int value) +{ + struct gpio_shared_proxy_data *proxy =3D gpiochip_get_data(gc); + struct gpio_shared_desc *shared_desc =3D proxy->shared_desc; + struct gpio_desc *desc =3D shared_desc->desc; + int ret, dir; + + guard(gpio_shared_desc_lock)(shared_desc); + + if (shared_desc->usecnt =3D=3D 1) { + dev_dbg(proxy->dev, + "Only one user of this shared GPIO, allowing to set direction to output= \n"); + + ret =3D gpiod_direction_output(desc, value); + if (ret) + return ret; + + if (value) { + proxy->voted_high =3D true; + shared_desc->highcnt =3D 1; + } else { + proxy->voted_high =3D false; + shared_desc->highcnt =3D 0; + } + + return 0; + } + + dir =3D gpiod_get_direction(desc); + if (dir < 0) + return dir; + + if (dir =3D=3D GPIO_LINE_DIRECTION_IN) { + dev_dbg(proxy->dev, + "Shared GPIO's direction already set to input, refusing to change\n"); + return -EPERM; + } + + return gpio_shared_proxy_set_unlocked(proxy, gpiod_direction_output, valu= e); +} + +static int gpio_shared_proxy_get(struct gpio_chip *gc, unsigned int offset) +{ + struct gpio_shared_proxy_data *proxy =3D gpiochip_get_data(gc); + + return gpiod_get_value(proxy->shared_desc->desc); +} + +static int gpio_shared_proxy_get_cansleep(struct gpio_chip *gc, + unsigned int offset) +{ + struct gpio_shared_proxy_data *proxy =3D gpiochip_get_data(gc); + + return gpiod_get_value_cansleep(proxy->shared_desc->desc); +} + +static int gpio_shared_proxy_do_set(struct gpio_shared_proxy_data *proxy, + int (*set_func)(struct gpio_desc *desc, int value), + int value) +{ + guard(gpio_shared_desc_lock)(proxy->shared_desc); + + return gpio_shared_proxy_set_unlocked(proxy, set_func, value); +} + +static int gpio_shared_proxy_set(struct gpio_chip *gc, unsigned int offset, + int value) +{ + struct gpio_shared_proxy_data *proxy =3D gpiochip_get_data(gc); + + return gpio_shared_proxy_do_set(proxy, gpiod_set_value, value); +} + +static int gpio_shared_proxy_set_cansleep(struct gpio_chip *gc, + unsigned int offset, int value) +{ + struct gpio_shared_proxy_data *proxy =3D gpiochip_get_data(gc); + + return gpio_shared_proxy_do_set(proxy, gpiod_set_value_cansleep, value); +} + +static int gpio_shared_proxy_get_direction(struct gpio_chip *gc, + unsigned int offset) +{ + struct gpio_shared_proxy_data *proxy =3D gpiochip_get_data(gc); + + return gpiod_get_direction(proxy->shared_desc->desc); +} + +static int gpio_shared_proxy_to_irq(struct gpio_chip *gc, unsigned int off= set) +{ + struct gpio_shared_proxy_data *proxy =3D gpiochip_get_data(gc); + + return gpiod_to_irq(proxy->shared_desc->desc); +} + +static int gpio_shared_proxy_probe(struct auxiliary_device *adev, + const struct auxiliary_device_id *id) +{ + struct gpio_shared_proxy_data *proxy; + struct gpio_shared_desc *shared_desc; + struct device *dev =3D &adev->dev; + struct gpio_chip *gc; + + shared_desc =3D devm_gpiod_shared_get(dev); + if (IS_ERR(shared_desc)) + return PTR_ERR(shared_desc); + + proxy =3D devm_kzalloc(dev, sizeof(*proxy), GFP_KERNEL); + if (!proxy) + return -ENOMEM; + + proxy->shared_desc =3D shared_desc; + proxy->dev =3D dev; + + gc =3D &proxy->gc; + gc->base =3D -1; + gc->ngpio =3D 1; + gc->label =3D dev_name(dev); + gc->parent =3D dev; + gc->owner =3D THIS_MODULE; + gc->can_sleep =3D shared_desc->can_sleep; + + gc->request =3D gpio_shared_proxy_request; + gc->free =3D gpio_shared_proxy_free; + gc->set_config =3D gpio_shared_proxy_set_config; + gc->direction_input =3D gpio_shared_proxy_direction_input; + gc->direction_output =3D gpio_shared_proxy_direction_output; + if (gc->can_sleep) { + gc->set =3D gpio_shared_proxy_set_cansleep; + gc->get =3D gpio_shared_proxy_get_cansleep; + } else { + gc->set =3D gpio_shared_proxy_set; + gc->get =3D gpio_shared_proxy_get; + } + gc->get_direction =3D gpio_shared_proxy_get_direction; + gc->to_irq =3D gpio_shared_proxy_to_irq; + + return devm_gpiochip_add_data(dev, &proxy->gc, proxy); +} + +static const struct auxiliary_device_id gpio_shared_proxy_id_table[] =3D { + { .name =3D "gpiolib_shared.proxy" }, + {}, +}; +MODULE_DEVICE_TABLE(auxiliary, gpio_shared_proxy_id_table); + +static struct auxiliary_driver gpio_shared_proxy_driver =3D { + .driver =3D { + .name =3D "gpio-shared-proxy", + }, + .probe =3D gpio_shared_proxy_probe, + .id_table =3D gpio_shared_proxy_id_table, +}; +module_auxiliary_driver(gpio_shared_proxy_driver); + +MODULE_AUTHOR("Bartosz Golaszewski "); +MODULE_DESCRIPTION("Shared GPIO mux driver."); +MODULE_LICENSE("GPL"); --=20 2.48.1 From nobody Thu Oct 2 00:46:10 2025 Received: from mail-wr1-f47.google.com (mail-wr1-f47.google.com [209.85.221.47]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 68B9B319877 for ; Wed, 24 Sep 2025 14:52:06 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.221.47 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1758725528; cv=none; b=bdHzimexgKJGD8MLEoTsn02YnrbLyGSqx245mNbGZ6PhpR0L3AW1m9+F2Is5ir9rKPMrNzhE8NqTU9XldqVvK4rVoMPtUzEh/bEqXl8OZJ8EGEuABpNfoZAjgomXdYrp2NfKJ872VjC2tJh6Y61/KfeKc9aayIQh9fQEOeI4P+g= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1758725528; c=relaxed/simple; bh=qNrM3GBnH0eKznG4kYP6/Avn4DKIB1tkLH4xpvp9N7Q=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=N/aOevyZPzFNhFYX2/FoZmFGaUUxAds8ThvV5LgHpFMoD777HB6MFbSt5yO5eWeL8bcKwBo+ReXgf5PdGqETvOaOJQM/UjuqG1o0IcRicoSjf2fohI9zkJY15BdOXKI5S4MTQwp1O4nlGoD5dDU3Kec5weC+SRFAsfhBhFzupck= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=none (p=none dis=none) header.from=bgdev.pl; spf=none smtp.mailfrom=bgdev.pl; dkim=pass (2048-bit key) header.d=bgdev-pl.20230601.gappssmtp.com header.i=@bgdev-pl.20230601.gappssmtp.com header.b=eMbb8ca8; arc=none smtp.client-ip=209.85.221.47 Authentication-Results: smtp.subspace.kernel.org; dmarc=none (p=none dis=none) header.from=bgdev.pl Authentication-Results: smtp.subspace.kernel.org; spf=none smtp.mailfrom=bgdev.pl Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=bgdev-pl.20230601.gappssmtp.com header.i=@bgdev-pl.20230601.gappssmtp.com header.b="eMbb8ca8" Received: by mail-wr1-f47.google.com with SMTP id ffacd0b85a97d-3ecdf2b1751so4170844f8f.0 for ; Wed, 24 Sep 2025 07:52:06 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=bgdev-pl.20230601.gappssmtp.com; s=20230601; t=1758725525; x=1759330325; darn=vger.kernel.org; h=cc:to:in-reply-to:references:message-id:content-transfer-encoding :mime-version:subject:date:from:from:to:cc:subject:date:message-id :reply-to; bh=ZL4+irwvWE4SsBdHoCJTCTy+AX9NkTo9OPK52JUB9wc=; b=eMbb8ca8sBdbWV0Fnz1eH0KykRRQYmtkuePWtVu84Y8tHj/69feWqnN685QVe5y3hj 1XhLPEWRhtJjxO6PurMHxkfnTjQcJWvx13LIWQF9887qpfFMTPVGEjSQsNVlWzga7n9D f7RlhjGvliW4/fqQsS6LpsV3n8U6k9EpZ05CS52XN/VES1PnPLqC6uH/vp8lX4J8JE4+ 55kdttOqk3V9QSQ7i6tmKB3DvPvFsg932HxM334PmlhMBIhoFoqOefdg4XFZ9j4CXVXQ hDPVbZy9MqrxCgUqcI5SulpL0fQGZCYM11x0QVLTIMwYBFLmzz/YQTVlerXLkfBKFkns c+0A== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1758725525; x=1759330325; h=cc:to:in-reply-to:references:message-id:content-transfer-encoding :mime-version:subject:date:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=ZL4+irwvWE4SsBdHoCJTCTy+AX9NkTo9OPK52JUB9wc=; b=H8o7xNTUd+evHTnmJtudijiUOb83WLGKsByJmN2wkt9H9rP1N3aEFvg4jfUPY6CP41 S/WHTPzeQTOvPYC5HGT+JVoBSoq8dcCteyaCPwz+JALDXJlz7pJKL2mUBjAIE3Xv8ksb IUriTCUFWzAlJB7STiLdnB5YKW34aiwp82+UFlcXcOWbio3I14BehPBcbV9VPrYL3Cyh lMVJCrXPwAq3d27Lm8qFXq3p6K7lhT3CqlN8wWtk146GtmkSs8z6VqjUBfso7bsraq+G 0GrFiT7Ae5AVPrbczP1Mb0Cv0pwGYAFbbUwsYVJjvykC83qUANSLJAFzEy7fdA906+4m TDZQ== X-Forwarded-Encrypted: i=1; AJvYcCWsHSgfwLm6mpN/SGAV1fam3WRhRs66ZRk8dvcBxH6CLk0eGQ6I7cr8wpTPTYDoV6m0w0Ui90KHUki7j24=@vger.kernel.org X-Gm-Message-State: AOJu0Yw0TIaQI3T3fNvQ1Oqrv8La+bkBJjyFYSTT1HQPChvSs8POzyjC YyIt6CZYNPob97YB6S8NEPNaqV5XcJG2zyeG7v9uCEkGe6iaLVexk25WRdTK3K1/E1I= X-Gm-Gg: ASbGnctlsmaO/h8KJ4sudHEYK87peVdUeqSJBgvQF0HIs42Jcxakc3rkQqkHmvnNNdY yNMsweqX/4W/lqQtRb9RRkWhg/S9OqwjzEGlU0kqQMOVofkkuEUsRIuJ5o9PBKGE/nrlMoSEqfL 7Z5G+66yKeKp5xnJKMyHcSjP5sdTvDiwelv34ZD5Ra70STfwA7+2NVMRNc2vuQ591Uab7oYrwtd Z71v3f918XgUjlJqs1pnzoQQEeEtZVLwyO126i3XmPGejKwHXdCXGjlGDp+DDEjnTWbNWGy6088 ixernXVDTalSmtiIDnmGcb7goxa7+i0HnfT+X/hSBnzAUP7tnry1OwqZWjaz7q12ulaKnm1PQ98 QxGZI/3AE/G/4Q3UygZ5LsV0/u9+1 X-Google-Smtp-Source: AGHT+IEWHNWM3PMiQi39DCUY0P65dMCtUAmW0aNINKZlaMoAKd9G+OFLiLVmnpWbGaFejBIGTe5r6A== X-Received: by 2002:a05:6000:22c5:b0:3f6:9c5a:e202 with SMTP id ffacd0b85a97d-40e4a8f9b01mr211100f8f.24.1758725524742; Wed, 24 Sep 2025 07:52:04 -0700 (PDT) Received: from [127.0.1.1] ([2a01:cb1d:dc:7e00:1729:c9b6:7a46:b4a3]) by smtp.gmail.com with ESMTPSA id ffacd0b85a97d-3ee0fbc7188sm29514750f8f.37.2025.09.24.07.52.02 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 24 Sep 2025 07:52:03 -0700 (PDT) From: Bartosz Golaszewski Date: Wed, 24 Sep 2025 16:51:34 +0200 Subject: [PATCH RFC 6/9] gpiolib: support shared GPIOs in core subsystem code Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Message-Id: <20250924-gpio-shared-v1-6-775e7efeb1a3@linaro.org> References: <20250924-gpio-shared-v1-0-775e7efeb1a3@linaro.org> In-Reply-To: <20250924-gpio-shared-v1-0-775e7efeb1a3@linaro.org> To: Kees Cook , Mika Westerberg , Dmitry Torokhov , Andrew Morton , Linus Walleij , Manivannan Sadhasivam , Rob Herring , Krzysztof Kozlowski , Conor Dooley , Saravana Kannan , Greg Kroah-Hartman , Andy Shevchenko , Bartosz Golaszewski , Catalin Marinas , Will Deacon , Srinivas Kandagatla , Liam Girdwood , Mark Brown , Jaroslav Kysela , Takashi Iwai Cc: linux-hardening@vger.kernel.org, linux-kernel@vger.kernel.org, linux-gpio@vger.kernel.org, linux-arm-kernel@lists.infradead.org, linux-sound@vger.kernel.org, linux-arm-msm@vger.kernel.org, Bartosz Golaszewski X-Mailer: b4 0.14.2 X-Developer-Signature: v=1; a=openpgp-sha256; l=4422; i=bartosz.golaszewski@linaro.org; h=from:subject:message-id; bh=D3LlX9JCIHILUSECKUB0i2KcvXBRhYifvdj8HcLrtsY=; b=owEBbQKS/ZANAwAKARGnLqAUcddyAcsmYgBo1AWGtEm9BZBoHOyi6MRlpVU3iN4/m5ugqizXb cb5jiakzJqJAjMEAAEKAB0WIQQWnetsC8PEYBPSx58Rpy6gFHHXcgUCaNQFhgAKCRARpy6gFHHX clvfD/9ggshaV+wkSDLG7IqfR2kbj7iMCsyqumue5okcVW4slPGxJZrj33JjG2A5jCcf5zg6aYH mBJRXK2dlpCQk6WnUdIITocpEX+OdGe7/sDWBRWoez9hMSLBgwjFRegmHLSTckq3MRMtccedLZj ktqpmoRdheHwIgrqtKKBYZEhMeSEfkFz5E5WwJ4XlzUmnS5XT0n/t1gpt4jHTmdrJRV9inQSCD7 3iEIFwiCcO8NV05SRR52jeC9dOiu/EnhQmKZ9+v5UvLDkbdpnLJA+HuRFKyegz6Jve2KB4jngsq iabVmFlK/1ZLkfzuA1OBa7Wcc2ca1XKXAFCXoqRqDhxMcB56XsKHpUnj9tOQ9br2hGjXCh1Dmm7 I/VgNk1ApegakrszD7wB+reSA4O8W+7flw4KRo821kAyRsSVxQm/gyAXYUHuVFfUA76aS0yE5Rq uedGX/Vc9Xa9J79webxMRgOyfdm03s8lWUxsqBWOupPZ7owkAMCk+NARXtgQvNyfhR9sofkHvpv wJUntMKhrtDw2qs/eMXDnzBG+3YLhGQg+bD351X+Auc/ZUnNt232Y9ndJpJKKCrf0gmtDNDQKWE jXk3uBqKSiBvrcGmhPTiIoqhXV1cBhxQf7FC4wyMQQpIdx4grMPvIc87j5rVL8IXMMpr1z/C/0l lBZI30IhdmleP1g== X-Developer-Key: i=bartosz.golaszewski@linaro.org; a=openpgp; fpr=169DEB6C0BC3C46013D2C79F11A72EA01471D772 From: Bartosz Golaszewski As the final step in adding official support for shared GPIOs, enable the previously added elements in core GPIO subsystem code. Set-up shared GPIOs when adding a GPIO chip, tear it down on removal and check if a GPIO descriptor looked up during the firmware-node stage is shared and fall-back to machine lookup in this case. Signed-off-by: Bartosz Golaszewski --- drivers/gpio/gpiolib.c | 50 +++++++++++++++++++++++++++++++++++++++++-----= ---- 1 file changed, 41 insertions(+), 9 deletions(-) diff --git a/drivers/gpio/gpiolib.c b/drivers/gpio/gpiolib.c index 9952e412da505c12ceddfefd9cfd778aad3bd5e6..1e4c991797126d0d91233bbe7c3= ae3831bf77d6c 100644 --- a/drivers/gpio/gpiolib.c +++ b/drivers/gpio/gpiolib.c @@ -37,6 +37,7 @@ #include "gpiolib-acpi.h" #include "gpiolib-cdev.h" #include "gpiolib-of.h" +#include "gpiolib-shared.h" #include "gpiolib-swnode.h" #include "gpiolib-sysfs.h" #include "gpiolib.h" @@ -1200,6 +1201,10 @@ int gpiochip_add_data_with_key(struct gpio_chip *gc,= void *data, if (ret) goto err_remove_irqchip_mask; =20 + ret =3D gpio_device_setup_shared(gdev); + if (ret) + goto err_remove_irqchip; + /* * By first adding the chardev, and then adding the device, * we get a device node entry in sysfs under @@ -1211,10 +1216,13 @@ int gpiochip_add_data_with_key(struct gpio_chip *gc= , void *data, if (gpiolib_initialized) { ret =3D gpiochip_setup_dev(gdev); if (ret) - goto err_remove_irqchip; + goto err_teardown_shared; } + return 0; =20 +err_teardown_shared: + gpio_device_teardown_shared(gdev); err_remove_irqchip: gpiochip_irqchip_remove(gc); err_remove_irqchip_mask: @@ -1283,6 +1291,7 @@ void gpiochip_remove(struct gpio_chip *gc) /* Numb the device, cancelling all outstanding operations */ rcu_assign_pointer(gdev->chip, NULL); synchronize_srcu(&gdev->srcu); + gpio_device_teardown_shared(gdev); gpiochip_irqchip_remove(gc); acpi_gpiochip_remove(gc); of_gpiochip_remove(gc); @@ -4652,11 +4661,29 @@ struct gpio_desc *gpiod_find_and_request(struct dev= ice *consumer, scoped_guard(srcu, &gpio_devices_srcu) { desc =3D gpiod_fwnode_lookup(fwnode, consumer, con_id, idx, &flags, &lookupflags); + if (!IS_ERR_OR_NULL(desc) && + test_bit(GPIOD_FLAG_SHARED, &desc->flags)) { + /* + * We're dealing with a GPIO shared by multiple + * consumers. This is the moment to add the machine + * lookup table for the proxy device as previously + * we only knew the consumer's fwnode. + */ + ret =3D gpio_shared_add_proxy_lookup(consumer, lookupflags); + if (ret) + return ERR_PTR(ret); + + /* Trigger platform lookup for shared GPIO proxy. */ + desc =3D ERR_PTR(-ENOENT); + /* Trigger it even for fwnode-only gpiod_get(). */ + platform_lookup_allowed =3D true; + } + if (gpiod_not_found(desc) && platform_lookup_allowed) { /* * Either we are not using DT or ACPI, or their lookup - * did not return a result. In that case, use platform - * lookup as a fallback. + * did not return a result or this is a shared GPIO. In + * that case, use platform lookup as a fallback. */ dev_dbg(consumer, "using lookup tables for GPIO lookup\n"); @@ -4679,14 +4706,19 @@ struct gpio_desc *gpiod_find_and_request(struct dev= ice *consumer, return ERR_PTR(ret); =20 /* - * This happens when there are several consumers for - * the same GPIO line: we just return here without - * further initialization. It is a bit of a hack. - * This is necessary to support fixed regulators. + * This happens when there are several consumers for the same + * GPIO line: we just return here without further + * initialization. It's a hack introduced long ago to support + * fixed regulators. We now have a better solution with + * automated scanning where affected platforms just need to + * select the provided Kconfig option. * - * FIXME: Make this more sane and safe. + * FIXME: Remove the GPIOD_FLAGS_BIT_NONEXCLUSIVE flag after + * making sure all platforms use the new mechanism. */ - dev_info(consumer, "nonexclusive access to GPIO for %s\n", name); + dev_info(consumer, + "nonexclusive access to GPIO for %s, consider updating your code to us= ing gpio-shared-proxy\n", + name); return desc; } =20 --=20 2.48.1 From nobody Thu Oct 2 00:46:10 2025 Received: from mail-wm1-f52.google.com (mail-wm1-f52.google.com [209.85.128.52]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id BAE0431AF09 for ; Wed, 24 Sep 2025 14:52:09 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.128.52 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1758725531; cv=none; b=EIozWPaXePTbEU846umhg1DdpcswYGORNO6ybZuwIhu3BU9/PqW+xprp/0C/H3Ws7MpuIEXJsdHkmwlTRCMBgVliuluelCXZVREQThux1PckkfeO3Srd0dCrOY9EboEn866rMlcih78ZoMWtkwBchS1nzzTd1MiS1Nkwi8gvymk= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1758725531; c=relaxed/simple; bh=qcX1d63axfEm3RBwV296f+6+sRglnyR7jSQ67K8y59Q=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=u3kgjqJwbDtkjznrqElgnAq4kLZakR6H5zkAwrupr68OotDILQT8HuxvwtfUPyVUuF1k3C5F5eLC7bcDHl9u6S9EIBYOo4xvVZuVXk83fnXcxmfdpAyoUVf7g68BK/9Xa2gF+dfYurpF+QjYJormxOhCbDt69ywlDUmPHX377Fk= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=none (p=none dis=none) header.from=bgdev.pl; spf=none smtp.mailfrom=bgdev.pl; dkim=pass (2048-bit key) header.d=bgdev-pl.20230601.gappssmtp.com header.i=@bgdev-pl.20230601.gappssmtp.com header.b=F1uZ4dEJ; arc=none smtp.client-ip=209.85.128.52 Authentication-Results: smtp.subspace.kernel.org; dmarc=none (p=none dis=none) header.from=bgdev.pl Authentication-Results: smtp.subspace.kernel.org; spf=none smtp.mailfrom=bgdev.pl Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=bgdev-pl.20230601.gappssmtp.com header.i=@bgdev-pl.20230601.gappssmtp.com header.b="F1uZ4dEJ" Received: by mail-wm1-f52.google.com with SMTP id 5b1f17b1804b1-46cbdf513d7so37499555e9.2 for ; Wed, 24 Sep 2025 07:52:09 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=bgdev-pl.20230601.gappssmtp.com; s=20230601; t=1758725528; x=1759330328; darn=vger.kernel.org; h=cc:to:in-reply-to:references:message-id:content-transfer-encoding :mime-version:subject:date:from:from:to:cc:subject:date:message-id :reply-to; bh=ibo0NSWbl5C+bQQFmoxlAmjW8oHbuGgT0ysyiGqJH04=; b=F1uZ4dEJwYU/q/uT5cIg2WhczgG4i3NNjrikY2TSzz8YgnQk/Zot9R2fFx6KFk64nB GHkJBI/T7m91xemjea8GOyyyIPUG+4OullhJQKrLZqY4Dz5MdmCAVv4qdLnJzHExWXx+ 6TjO2IBPQkBkW7/XdnRxCDkjfhwg5afy8OLpEDnotXhluGtTt/qbQPLycfham+idZ1Vo bktbhRi2k/yMC9F/9x9yN8u0Qo40lwB/vFZxIFJBansI0kRznZ3iXeCrJ1v+usZVjxG9 JKdtRVz8SgKjKlR9NpEIEFNr2HjLtZoPnmqVCPOUYAR05dxMH9B48EZw4YvVbWWbXJ4O tqzg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1758725528; x=1759330328; h=cc:to:in-reply-to:references:message-id:content-transfer-encoding :mime-version:subject:date:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=ibo0NSWbl5C+bQQFmoxlAmjW8oHbuGgT0ysyiGqJH04=; b=FFm1Kt5stYCEhHGbmE9KTvCVNDxdWLLHgto94IPxVq3jlBB3Kvt/1oj5y4t4VVtqeM 0bOsuFkcSQouUpuGHjkGjm3dn2If1T2bTW6W1O5QOf2lElOUNap5w3XrFeqeZs4WKpa0 Q1qk6Jo6ghyfSpihjhhdfoAdzck+7wiCi8SVjKRk5lrJN7KS1TYaRFn7nlJCA0bmnv6F XfY52AYm75JTndwCq+4IMvaogRYDn57x/A2MK5ptEEhJ4Y++wdeCG4Uzkd7qKc3Sid6H 1Rn0/IYXkBUOSk8bgE4zPm4ps/z5EhusolBdhZTTvBQocnp8a6K+UeQ6G2Y4JqjmxTE4 DAwg== X-Forwarded-Encrypted: i=1; AJvYcCVKFtwqrii/hUNXzp/rjxCWNSCJxxAaalHktmuVv6Iux3eA5U/MUZkRfa/m2q/I6RDxqT+5AmSBvxNA93s=@vger.kernel.org X-Gm-Message-State: AOJu0Yx5DcvCNRbXLN6X8hTVEvLy5oR5kaDLIYmu72DZVLj2xVg0xSBC fYYiZ/TkUl9noNKLDcPseNWEN7sAW08oKAjJ5vJxveYu0L5I2vYu3Npnk/hv7pDBqM4= X-Gm-Gg: ASbGncslYNIbiJsKf1I+eJGOYVTXlBjztRE2D7QZsD9v1VSf8zzXAisfjffb5FizW27 5IxbdT8VkHot3FiLDNs7zByDQ+pRGho+3a7dXcJxk1i6yZS+KgGIx7semyK2WaaDnxwPzGBXDrv eswmlMASmP9Mt6oDLDah5ghbNqHkf+K1j6eKnHNPhl5ZOfUFZ8BJrH5hLhks9E+W7xNVngDnHdy O4kGXFxNHbjdaX+VQoNzhu5q5zeIqbUWQWojNjMgYE3Bu3bivlrSQHmYm6JjRIPKiUoO7qrMP1t R4s9dByjGDnEpoxLptEO5uqWP+i0VKZA9Jrj8KQKpMUQ+OncpC2N5aANbfYq/P+ON5ok+/ma9T9 Fg1T+8oubY25cYP9YaQ== X-Google-Smtp-Source: AGHT+IH2UM0b2DoB2jVzXodkJqn7cNt+S1+id56qPKU1HujmDmjEKCztQlK5G0qjmChMEW9QPceS2w== X-Received: by 2002:a05:600c:4b19:b0:46d:b665:1d95 with SMTP id 5b1f17b1804b1-46e32a23f8dmr637135e9.32.1758725527921; Wed, 24 Sep 2025 07:52:07 -0700 (PDT) Received: from [127.0.1.1] ([2a01:cb1d:dc:7e00:1729:c9b6:7a46:b4a3]) by smtp.gmail.com with ESMTPSA id ffacd0b85a97d-3ee0fbc7188sm29514750f8f.37.2025.09.24.07.52.04 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 24 Sep 2025 07:52:05 -0700 (PDT) From: Bartosz Golaszewski Date: Wed, 24 Sep 2025 16:51:35 +0200 Subject: [PATCH RFC 7/9] arm64: select HAVE_SHARED_GPIOS for ARCH_QCOM Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Message-Id: <20250924-gpio-shared-v1-7-775e7efeb1a3@linaro.org> References: <20250924-gpio-shared-v1-0-775e7efeb1a3@linaro.org> In-Reply-To: <20250924-gpio-shared-v1-0-775e7efeb1a3@linaro.org> To: Kees Cook , Mika Westerberg , Dmitry Torokhov , Andrew Morton , Linus Walleij , Manivannan Sadhasivam , Rob Herring , Krzysztof Kozlowski , Conor Dooley , Saravana Kannan , Greg Kroah-Hartman , Andy Shevchenko , Bartosz Golaszewski , Catalin Marinas , Will Deacon , Srinivas Kandagatla , Liam Girdwood , Mark Brown , Jaroslav Kysela , Takashi Iwai Cc: linux-hardening@vger.kernel.org, linux-kernel@vger.kernel.org, linux-gpio@vger.kernel.org, linux-arm-kernel@lists.infradead.org, linux-sound@vger.kernel.org, linux-arm-msm@vger.kernel.org, Bartosz Golaszewski X-Mailer: b4 0.14.2 X-Developer-Signature: v=1; a=openpgp-sha256; l=735; i=bartosz.golaszewski@linaro.org; h=from:subject:message-id; bh=LQ6GmHpD/iWFySPYiWNs4nA4WFevXV0FDAv5KxrY5e0=; b=owEBbQKS/ZANAwAKARGnLqAUcddyAcsmYgBo1AWGfry/qkeWFwp5USy/SVwuycKAk3dAKJzbt 0gOWPScWyyJAjMEAAEKAB0WIQQWnetsC8PEYBPSx58Rpy6gFHHXcgUCaNQFhgAKCRARpy6gFHHX cqo4D/0R7BakY98Bieuwd9AXA5Zz3ZPzUXUHxuC407kcVrlX4alt2GtuQcMPCAS4/e6+vlNQRNO gDZhb71YkyFGZxgwFPPt1MxOMN/buFbmL3CTvTWwOOPx8TaKDO/whWvLq8R+u16ltl2k4g2zBzP gfrA9rXzjl/jkf4hjCnRDeXFDTKKg7X4eKOOX/UTX8mTSKBwbCRXQMza5ygAvvl0YGoFM2ZgE4l J/cWLJSWqJU/9P12SYQPt+bsmOhXSvp5FYJ6QBv8+6fdDWD54kBEktJRBdShjrK1pVoiiCRd01F 2S2IRfykO5jZiju4Bvo37TSestnnupumzoC3I+FzdsoSC9qpOprXBct1IPk7kJk+ndtID3zOioY sFR2bORVE+q0qo4jHu9ETc1ffR0uGNl0hFjEoClR2HwlLr3YIaLbHR5FtLXB3erXC5GyPr7JfTN dusEehQcGYYM4r37bWusqOhdg+aqvCdwn+i9UXVYwnXKR2mE1+VeRB74CDxm7MqqU5VO8AJxMoQ jFIen2jZnt4Ch30oPMyaSA/TcR659d9+U9+0c6GzqkiGwufduZoayKA9Odsny/iIfr/bzGYLrJb l0hjNAXa8pv4FcvrvTkFXt9nGiemMn/I6g9khHxqM7bvzGsmU+v3ojYDcKsNw21/T0dEgFXkSUF OM8RQivtzHHfEkw== X-Developer-Key: i=bartosz.golaszewski@linaro.org; a=openpgp; fpr=169DEB6C0BC3C46013D2C79F11A72EA01471D772 From: Bartosz Golaszewski Some qualcomm platforms use shared GPIOs. Enable support for them by selecting the Kconfig switch provided by GPIOLIB. Signed-off-by: Bartosz Golaszewski --- arch/arm64/Kconfig.platforms | 1 + 1 file changed, 1 insertion(+) diff --git a/arch/arm64/Kconfig.platforms b/arch/arm64/Kconfig.platforms index 13173795c43d4f28e2d47acc700f80a165d44671..3dbff0261f0add0516d8cb3fd0f= 29e277af94f20 100644 --- a/arch/arm64/Kconfig.platforms +++ b/arch/arm64/Kconfig.platforms @@ -316,6 +316,7 @@ config ARCH_QCOM select GPIOLIB select PINCTRL select HAVE_PWRCTRL if PCI + select HAVE_SHARED_GPIOS help This enables support for the ARMv8 based Qualcomm chipsets. =20 --=20 2.48.1 From nobody Thu Oct 2 00:46:10 2025 Received: from mail-wr1-f42.google.com (mail-wr1-f42.google.com [209.85.221.42]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id C123031B10E for ; Wed, 24 Sep 2025 14:52:11 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.221.42 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1758725533; cv=none; b=rSMHKWtydlviP5ITAtgu85F/8LhEdoTa7MCeRu9NIM6ZKJtf4f2AOez4/+oJuZV0Ja9nBnUha/oqB/l/uIOHxqPrA9iZJq6BeSHFPsXhwfGj5buXNuUtK1w32bQ31ZEsmqlmb/XdT7zt4TR/OpGlo/t/GLCGK83b1UB89ptKJ6A= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1758725533; c=relaxed/simple; bh=o3clotEVXCzqMxW1qJk3uiRPSq6aP6WSAmpPzr7h58A=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=B+tcuM65fSV4/JniSPVurZa6EdT6xL+0xAWQH/11+r9f7H+UFwINprh3ROzQAjFNi6pVSn+qLa7vHu0t6XlBToH/etGdUD3SRkupUAi6Yo5yZiaBo71u8Z9pKfqwJewLWQp3BuvEDwRkd8g+cSmsKpx7SyMvXOd+gDpd8DoGUJc= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=none (p=none dis=none) header.from=bgdev.pl; spf=none smtp.mailfrom=bgdev.pl; dkim=pass (2048-bit key) header.d=bgdev-pl.20230601.gappssmtp.com header.i=@bgdev-pl.20230601.gappssmtp.com header.b=LX6tj7XB; arc=none smtp.client-ip=209.85.221.42 Authentication-Results: smtp.subspace.kernel.org; dmarc=none (p=none dis=none) header.from=bgdev.pl Authentication-Results: smtp.subspace.kernel.org; spf=none smtp.mailfrom=bgdev.pl Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=bgdev-pl.20230601.gappssmtp.com header.i=@bgdev-pl.20230601.gappssmtp.com header.b="LX6tj7XB" Received: by mail-wr1-f42.google.com with SMTP id ffacd0b85a97d-3ee130237a8so4038339f8f.0 for ; Wed, 24 Sep 2025 07:52:11 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=bgdev-pl.20230601.gappssmtp.com; s=20230601; t=1758725530; x=1759330330; darn=vger.kernel.org; h=cc:to:in-reply-to:references:message-id:content-transfer-encoding :mime-version:subject:date:from:from:to:cc:subject:date:message-id :reply-to; bh=JSTA3g5ank1TH+h8Aobptwj96daqy8jbcBAobAq2Oqo=; b=LX6tj7XBbF5A94cSXoUra3tvkYB/nhISdHqZajinQsqjWNgX1NCPsQ6I5XSIpUVoQH VMPg4q7SPPujwN5mUrKvGoHSRUmtIG8+rI6oXDwWIjhWAYEWVyJN50nzKfwpWZ7Ou+TK xsoARAANfZxb0l1+xIVzRglq7A7li646FL96KRzunURr4LJsBs5QcSlalj7rFjUBg42O V4oazIwK5gPOQpjl0xz8Rw2mN/hv1kY5sNfb3Q9a6er8Es6aCEB4gde3F6sA5ZLR9ZC2 HQo56A7goh8MxExvMpfNMmTRYjgTa5E6g7WAIgywV79rsjAXNp8CctOsT9KLlIH4xou+ bIsA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1758725530; x=1759330330; h=cc:to:in-reply-to:references:message-id:content-transfer-encoding :mime-version:subject:date:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=JSTA3g5ank1TH+h8Aobptwj96daqy8jbcBAobAq2Oqo=; b=H5qYey+I5f/q+HpwKYpGVOccSmnUK1KOGJu6+LS4ipwgAyCXGPAjHmMx5mhIz+SH2a cBdLQl1xBdfQfC0NG5DSmgysM7oNpr42wbM82IHAgSDkzxdHvmlv3aYpmHtReLPx8V8I yvaGsTAe6Yf9jWmo0jVy2JhBkpO2VxpBxKvOttjgrJX4MAHbphr34TDNCgjYwSAwBHAg 5cXuIJJkxoUqlQyNjCgwlPlKXvfmRznckWZMzHH5T7Fpff3F7jiVeXKOUTWh2VS8ycHo xfV+XlQZ7gjhiRWy+ZJWiGLtFUlVpn+ZU1bE3aL5nYVMAXPmfkeOv3wqt8qdkPLeFIQZ xnaw== X-Forwarded-Encrypted: i=1; AJvYcCXExASb0po1ZpJnuAgf0uFA5iZoVcU/SMJp+TGIJPERCw0c2KxuG0dMc3Xm7dXgIzBqIp7mO3+hnx9wxmo=@vger.kernel.org X-Gm-Message-State: AOJu0YxA5IFjkztZar3kK6Hc45AcacJT4hnPCC6Tq9z92f7juc2o6q3R 9YoF2gOa385f3aNBATLJ0pP/974tc/EmMzq5zhEJV0E3GALCFiPzA99DV9IFq/hQcgQ= X-Gm-Gg: ASbGncsWlj7yd4N+hyvDx4Js/TxioFh2XKjEUmBK99RD04vr1HoUZiLOOP+ncgYrnJF lGOHIIpLlo3LpXau5RFW/g0r8C8uMt+HOvwSJ0NxRSZywJ+vT+jXnJDhgl4GtzXWrWmfBOK0AQY FERT4IArKvY74d+hsfP1a6yofnwdMJJW/dDDqVb+yrEtI8cOfdcn31FV8JNXff9BdY/mq54bECl sNI9mxI4SEW5PZX45VsakJBOtAlbKyijPFtcAc8x5Nct04KBooNlKBMYjCxV8VWGTIF6DiiprWI M4IBtGUgzSUW48ukB405sYhR3CZDryZ3qD+SPYUsRnh6FMCo9/jRlwvillSvfbrQMI2F3QRFXrV 7nIUr78yCDUTR++teTBztnRoMXRej X-Google-Smtp-Source: AGHT+IHo7hPpbL4ZM5xq7bjjRM9vk1iuX0jyZL5Qov4depu+7BABKiS+a1RzqJgCrKv8lOkO/9BmkA== X-Received: by 2002:a05:6000:26ce:b0:3ee:15b4:8470 with SMTP id ffacd0b85a97d-40e4be0c962mr219796f8f.45.1758725530045; Wed, 24 Sep 2025 07:52:10 -0700 (PDT) Received: from [127.0.1.1] ([2a01:cb1d:dc:7e00:1729:c9b6:7a46:b4a3]) by smtp.gmail.com with ESMTPSA id ffacd0b85a97d-3ee0fbc7188sm29514750f8f.37.2025.09.24.07.52.08 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 24 Sep 2025 07:52:08 -0700 (PDT) From: Bartosz Golaszewski Date: Wed, 24 Sep 2025 16:51:36 +0200 Subject: [PATCH RFC 8/9] ASoC: wsa881x: drop GPIOD_FLAGS_BIT_NONEXCLUSIVE flag from GPIO lookup Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Message-Id: <20250924-gpio-shared-v1-8-775e7efeb1a3@linaro.org> References: <20250924-gpio-shared-v1-0-775e7efeb1a3@linaro.org> In-Reply-To: <20250924-gpio-shared-v1-0-775e7efeb1a3@linaro.org> To: Kees Cook , Mika Westerberg , Dmitry Torokhov , Andrew Morton , Linus Walleij , Manivannan Sadhasivam , Rob Herring , Krzysztof Kozlowski , Conor Dooley , Saravana Kannan , Greg Kroah-Hartman , Andy Shevchenko , Bartosz Golaszewski , Catalin Marinas , Will Deacon , Srinivas Kandagatla , Liam Girdwood , Mark Brown , Jaroslav Kysela , Takashi Iwai Cc: linux-hardening@vger.kernel.org, linux-kernel@vger.kernel.org, linux-gpio@vger.kernel.org, linux-arm-kernel@lists.infradead.org, linux-sound@vger.kernel.org, linux-arm-msm@vger.kernel.org, Bartosz Golaszewski X-Mailer: b4 0.14.2 X-Developer-Signature: v=1; a=openpgp-sha256; l=937; i=bartosz.golaszewski@linaro.org; h=from:subject:message-id; bh=vspstOLquen8UYYEalfT4SF6xCukX3qfgdJchdoYapg=; b=owEBbQKS/ZANAwAKARGnLqAUcddyAcsmYgBo1AWGMBU259VWbLUFQV6SPSQ1mCX0iBW23guMa VXKoI+zVNmJAjMEAAEKAB0WIQQWnetsC8PEYBPSx58Rpy6gFHHXcgUCaNQFhgAKCRARpy6gFHHX cvj7EADf10cfXI03PODvy6iln82xUiPu89UJlugKSbbUiWCkjYBUDIBAkVerwrnChTfbjHklBlo QUwiI+HkzY/nBc0LJyuNwptKpjTuk0LrX+T08cIKUntvoXc9WetrGMPVFQ321J1SApioK1TqDtN eoGSM3XqRfRMsDAVYZlSCbq80fpyJMFlhljP/c8+obGy4YZwce6bthnE3ybROshaTXJcP3gTINk 95vvtfxAr+pRCqipNgqPcbeX3oLJbZ/MVQZC5mEj+2xSCwkYJKXrkXHB2aae20UeTJZHfYaqSvC H2DOs/6NLW6ml/KfZjRvfjfaA+VTqD7cn4iV7/PtDDLkCvcamm/OA+lQ07D61TF1I8M9bUVbn5u A21uSs++ScVL6XfDunZtHE75ylZXpRIp6VZ866ltMYEjWd1FKnxDdDeTvZE1/CiZYywppWzayxV fHPPn8s+btRwJ/0TUj+czn2GFqIOzixzbELM9gw8Z+ULFwWN4LOOcwj2ZykbMa9VzR1DgAGnpw1 Aq9Cni1x/fjU2gmiHPy4LNG6375hP+wT8EIGg6URIzJkQ6ljy/t2wMCfVww9AGfhEDzGonwAvxC Zo9kN9wOH6p0IRXa5eL/6tmPExvW+oMuBd9LOPTJFzWwtCL40ZujGTgOzuq5S20xvsaPQlcBnrW Z6DRjLjjbDf35Uw== X-Developer-Key: i=bartosz.golaszewski@linaro.org; a=openpgp; fpr=169DEB6C0BC3C46013D2C79F11A72EA01471D772 From: Bartosz Golaszewski This driver is only used on Qualcomm platforms which now select HAVE_SHARED_GPIOS so this flag can be dropped. Signed-off-by: Bartosz Golaszewski --- sound/soc/codecs/wsa881x.c | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/sound/soc/codecs/wsa881x.c b/sound/soc/codecs/wsa881x.c index 636e59abc3772fc0b333873a329b65f4213c3ef3..92a1e3bb8371e178571a6c1ed6f= 1185fe6c2e757 100644 --- a/sound/soc/codecs/wsa881x.c +++ b/sound/soc/codecs/wsa881x.c @@ -1112,8 +1112,7 @@ static int wsa881x_probe(struct sdw_slave *pdev, if (!wsa881x) return -ENOMEM; =20 - wsa881x->sd_n =3D devm_gpiod_get_optional(dev, "powerdown", - GPIOD_FLAGS_BIT_NONEXCLUSIVE); + wsa881x->sd_n =3D devm_gpiod_get_optional(dev, "powerdown", 0); if (IS_ERR(wsa881x->sd_n)) return dev_err_probe(dev, PTR_ERR(wsa881x->sd_n), "Shutdown Control GPIO not found\n"); --=20 2.48.1 From nobody Thu Oct 2 00:46:10 2025 Received: from mail-wr1-f47.google.com (mail-wr1-f47.google.com [209.85.221.47]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id AF95031B10B for ; Wed, 24 Sep 2025 14:52:14 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.221.47 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1758725538; cv=none; b=rISJSwxvzCoFl4BXvXT1OXae/6mzUFxqogclsf3ZTco9Ta0j1tbvPt4quK0W5mSsdv1BRGTuu514QbigX4Bm5qrxN9g0UPU+QSadivcZG7Qx+IioV1I0AFus+z4ycDD5DcJ12Inhz5X9ZtPi54CaeQ+Q3BO3kpn9CoBe6p7RU44= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1758725538; c=relaxed/simple; bh=kA7iX9loqcR1iPNQOHLnQ9pDOo+AVwSl3LLk/F4br8U=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=jyL6V/3FK03YOoOqzbCAdxrLmp0bLPLM5r9QKpKH/S7zKbn/ujttVz/XTDKcBkbnLQGvA2CI1VLW7bcdCpYSJpN0Ic6fianH80oxDLPDh+E/+zxfhL68SV9wPfKlRw7+mR6eO2pqnMwsF7k7WlVXvinG8CzMe5tn/Q3lqTYkbjs= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=none (p=none dis=none) header.from=bgdev.pl; spf=none smtp.mailfrom=bgdev.pl; dkim=pass (2048-bit key) header.d=bgdev-pl.20230601.gappssmtp.com header.i=@bgdev-pl.20230601.gappssmtp.com header.b=rkbIF0wW; arc=none smtp.client-ip=209.85.221.47 Authentication-Results: smtp.subspace.kernel.org; dmarc=none (p=none dis=none) header.from=bgdev.pl Authentication-Results: smtp.subspace.kernel.org; spf=none smtp.mailfrom=bgdev.pl Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=bgdev-pl.20230601.gappssmtp.com header.i=@bgdev-pl.20230601.gappssmtp.com header.b="rkbIF0wW" Received: by mail-wr1-f47.google.com with SMTP id ffacd0b85a97d-3ee15505cdeso846696f8f.0 for ; Wed, 24 Sep 2025 07:52:14 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=bgdev-pl.20230601.gappssmtp.com; s=20230601; t=1758725533; x=1759330333; darn=vger.kernel.org; h=cc:to:in-reply-to:references:message-id:content-transfer-encoding :mime-version:subject:date:from:from:to:cc:subject:date:message-id :reply-to; bh=ndMaJDazpE5vfGfuGA/DbEp6kihBYbJYnxWQMZaUODQ=; b=rkbIF0wWiiVi3XAxja1+YxX81Ry7Rb3TCnWgON2cQ/qp0VfhvoZS0bdOIAqrNtC60t s38zVQGwI4FIKdqzHuzD448DP7XYfsIUNzAITNDCdnEyq6VVNr5zGmVbugXuVIpXZ7NO fJfmVRdPqDp/V43lq2E8AKMJh6dsyMkk611nxXhbrp9kBUNNdAlf0s3mYSC0p7R4bjer Dq0+gki5JGmFw8iAg8498/c7gGR/b6gNhSjwDyQOom6pN5P19lm8Sxip8umjA6wIX1YG ciM77BHJa6vqaI/BdbHuDvXBTZVbmkpS9IMIfBtfI8kVM95RRoGK5zA7ZPTlrosffUYW bCqg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1758725533; x=1759330333; h=cc:to:in-reply-to:references:message-id:content-transfer-encoding :mime-version:subject:date:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=ndMaJDazpE5vfGfuGA/DbEp6kihBYbJYnxWQMZaUODQ=; b=K2I0Osw1VOVVjhQzicmZd4h5HAdZAcabR9Qi98olwUyMETVRbLF0iOPNq9tmkuwtRk /pQuiFAjRE8Ae4ZkgfQrIDo50JR6PKZjUfcECecRf1uq7nBN2fflQ9tM034jByeyF6M6 nt2YEIOLsuUVH84ti6FwIyYEkgxT/ZTVn+Igv0+1sYqNjKQzqPuHYyRB3R4rWrpM9atX WSYbwDd3F8BLanWhAeJyvQ6z3JFQq9KmpS/5DqUSrYn5EhYQdS89NXGgRlFyThlCAovu STD4jy2FjXl9dd+3ibhwl2DCSPQa5P1cUEaTlWghOZX/2WasqhVdsbwkEOuDFHo1Wk+d WnRA== X-Forwarded-Encrypted: i=1; AJvYcCXBTDdyOk8Hs66fcHXF2D2lLPb/Dw2yYB7u/gE/nQp0lZfXmTetHJfkxwLk0rWxean+d9Eb2b/MrJUDIaA=@vger.kernel.org X-Gm-Message-State: AOJu0Yx5HzqYGUvVZPYyc6OmPr6z+iO7LyqdCZNQCy2c0wX9e95uI9Vw Dflwc7tXKr7Sk+YxqgXtMX51AenUp2NNcViKJ7O0+HA5dxIEo6Mh42l/fXOlZo7y+nwSjMT6lDV B76vl+YSApQ== X-Gm-Gg: ASbGnctq0YKaztHpNaEketfDVSPuuZa5zrp5MrjLRTdp1uEpE1c79cMHxtSwO7TX63b B65og1/lpjCn8NpiH+vuhMnx+b+2MKb9AoOLKCzGiKxZLHO0C5jCGtiZ45pVtjtGOwe7/DbaJZV YsOm2rFJYj2DCTEx8/koheZGRbzV42BQ3p1JtCrLGCWNQrfYxoXunVmXpQes+MZ4qEPaSI1o5T3 bWMOwpFLBVSJnvkU1df0cpfEWOO5Kukt8CZA1kp+6HTPgs8eYjA4/sPlZ8n2TY+CrhdwKNqGTT+ pkjbcTW3m0ALB0W1ilZ/Regn0XrFO9bkgJ9fO5i+s6mYtWv8Li1AVfKTu7jAlf7AHVTYamabNlE 7ZSMWewEF7xlolpnDLksU9hUeRpCh X-Google-Smtp-Source: AGHT+IHNoygF5K6NbFZFn73ylgRAxtpGZVjEv4fnMw43TW4zazr6wr096y7fD1mLuRt7rZlC64ts9g== X-Received: by 2002:a05:6000:2010:b0:401:ae97:a1ab with SMTP id ffacd0b85a97d-40abe093fdbmr2608816f8f.10.1758725532824; Wed, 24 Sep 2025 07:52:12 -0700 (PDT) Received: from [127.0.1.1] ([2a01:cb1d:dc:7e00:1729:c9b6:7a46:b4a3]) by smtp.gmail.com with ESMTPSA id ffacd0b85a97d-3ee0fbc7188sm29514750f8f.37.2025.09.24.07.52.10 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 24 Sep 2025 07:52:10 -0700 (PDT) From: Bartosz Golaszewski Date: Wed, 24 Sep 2025 16:51:37 +0200 Subject: [PATCH RFC 9/9] ASoC: wsa883x: drop GPIOD_FLAGS_BIT_NONEXCLUSIVE flag from GPIO lookup Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Message-Id: <20250924-gpio-shared-v1-9-775e7efeb1a3@linaro.org> References: <20250924-gpio-shared-v1-0-775e7efeb1a3@linaro.org> In-Reply-To: <20250924-gpio-shared-v1-0-775e7efeb1a3@linaro.org> To: Kees Cook , Mika Westerberg , Dmitry Torokhov , Andrew Morton , Linus Walleij , Manivannan Sadhasivam , Rob Herring , Krzysztof Kozlowski , Conor Dooley , Saravana Kannan , Greg Kroah-Hartman , Andy Shevchenko , Bartosz Golaszewski , Catalin Marinas , Will Deacon , Srinivas Kandagatla , Liam Girdwood , Mark Brown , Jaroslav Kysela , Takashi Iwai Cc: linux-hardening@vger.kernel.org, linux-kernel@vger.kernel.org, linux-gpio@vger.kernel.org, linux-arm-kernel@lists.infradead.org, linux-sound@vger.kernel.org, linux-arm-msm@vger.kernel.org, Bartosz Golaszewski X-Mailer: b4 0.14.2 X-Developer-Signature: v=1; a=openpgp-sha256; l=1242; i=bartosz.golaszewski@linaro.org; h=from:subject:message-id; bh=xxM5DFs0HrWkdhU2lVlfFzKEyxjnJBr+LeYHk9Z5T9I=; b=owEBbQKS/ZANAwAKARGnLqAUcddyAcsmYgBo1AWGsIAdL4UJeiMya3ALuTFpKjTN7aiOFeRzH +UVHZT5JrCJAjMEAAEKAB0WIQQWnetsC8PEYBPSx58Rpy6gFHHXcgUCaNQFhgAKCRARpy6gFHHX cphcEACKy+MOIGJFHlexGtoihY6/OLkWdmrBXTUoO645qSw8NQvk7z2y3yUjzvjBKr9hX81y36k bi2ATgazhH2Y1qvRZLbCIyviBSlA/Ng/tlMWhAih3C07fcUG4xSkIpQmEvG11WfZbM1/JEdat4H oD3+pxKwrYyGakphDygC2/1nRA6QdzY6faa2Z6Q1DULdAyY6UoySb7D4odXllJNuZyJCCtiqxWE ubY3EMGOgrUzkIo5o17rtWlh6q+lU86nd59+duDIMpp6jgsUk/A1crptrmnhptqlh4HqNaUyHSS rS+ejjtDOTT46Z1nSE5u86Pg8+VJOjulDbM+epJg7NwA8n/Nz4uSLBbYABdnCaq3kG4s4OYHoGW 2EUoRTdUaKhnQOn2B/C8/W6zEkf+y6PjFboefj7wsslTNN7vlPo4vYmHA7jdCnDzWs4cW3AEdOZ sMMbRrfmlrfPatsBaEL+HZH71qMXTu/zBucKIg58ZckX9wKRAS+FWVtm04JHuuqGgS1XtkMwu4p Szr//k1rQp23kajM4IU5f9EUL1JLmpeoiDQEjUKcS1u0OiMeqkC+5RrMHwKd4uP6zPFkpkaQcLQ VSogCIlRTTQ4/NIBHy7HHxQD5Ehky/V5JKlAuCEStvEZ/XxunMEiLV0qz5adX0fh3iAMdhZ8igI MtfsM1m9NuzFvHw== X-Developer-Key: i=bartosz.golaszewski@linaro.org; a=openpgp; fpr=169DEB6C0BC3C46013D2C79F11A72EA01471D772 From: Bartosz Golaszewski This driver is only used on Qualcomm platforms which now select HAVE_SHARED_GPIOS so this flag can be dropped. Signed-off-by: Bartosz Golaszewski --- sound/soc/codecs/wsa883x.c | 7 ++----- 1 file changed, 2 insertions(+), 5 deletions(-) diff --git a/sound/soc/codecs/wsa883x.c b/sound/soc/codecs/wsa883x.c index ca4520ade79aa2c9377449e29cdd33e9e8dd28c5..ba60b4de6cab7740cd8aa70c89f= 6e03e1dc2dd12 100644 --- a/sound/soc/codecs/wsa883x.c +++ b/sound/soc/codecs/wsa883x.c @@ -1572,13 +1572,10 @@ static int wsa883x_get_reset(struct device *dev, st= ruct wsa883x_priv *wsa883x) if (IS_ERR(wsa883x->sd_reset)) return dev_err_probe(dev, PTR_ERR(wsa883x->sd_reset), "Failed to get reset\n"); - /* - * if sd_reset: NULL, so use the backwards compatible way for powerdown-g= pios, - * which does not handle sharing GPIO properly. - */ + + /* if sd_reset: NULL, so use the backwards compatible way for powerdown-= gpios */ if (!wsa883x->sd_reset) { wsa883x->sd_n =3D devm_gpiod_get_optional(dev, "powerdown", - GPIOD_FLAGS_BIT_NONEXCLUSIVE | GPIOD_OUT_HIGH); if (IS_ERR(wsa883x->sd_n)) return dev_err_probe(dev, PTR_ERR(wsa883x->sd_n), --=20 2.48.1