From nobody Wed Apr 8 06:06:07 2026 Received: from mail-wr1-f52.google.com (mail-wr1-f52.google.com [209.85.221.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 E23F432862F for ; Wed, 29 Oct 2025 11:21:00 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.221.52 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1761736862; cv=none; b=eKNuRwPy00QZX+WOYK4Q47RoVUHg8YSgAMkxNEjVbhahKAouWAKcBugDUi42d9f9ArPmGAhPiJ80Eh9l6gt93wvY5LJ6OTdEdyuoTHZZINKWjmbxNaszuHAYlGCzk78sow3glO145OX1nGZQrSrtQPbp56bMgKjOvoFmoamqR5U= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1761736862; c=relaxed/simple; bh=xqwlDgeQ89A6k5YIQo0IueQM8jBP+yv/zbt5OFOnI+Y=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=tldbcRHa2Hb0KM4Fxp1bykn17txQ9i6h1fdb9Krk8SJ0222rbL8nqNP63LUhw6pRXNMwc9HN6MQ3q1gYH13wNoko+L0KiTdC2tyZx7gmj5M9AwGkD8mNLPGe16j5XF2f06sfnRQoHlHAeRcs/2o8DV3FCw0pWYFkTNejK78UHoY= 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=A6tMZHJR; arc=none smtp.client-ip=209.85.221.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="A6tMZHJR" Received: by mail-wr1-f52.google.com with SMTP id ffacd0b85a97d-42421b1514fso4967555f8f.2 for ; Wed, 29 Oct 2025 04:21:00 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=bgdev-pl.20230601.gappssmtp.com; s=20230601; t=1761736859; x=1762341659; 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=KNfVvIhx701ah8nru3+V19npf0IYFyMM9HJ8zi25jFQ=; b=A6tMZHJRIBK7+qW2yrMhMcL9T9fZ7HjK9FOaP9Oe7AEYhJijahNVf8EDbR2NMuAh+h xrvaYlaW2AQBpeJpyPWSjRq8KB15ilyuXK2SzB8I9pYPhD7qSU2oYSgn3kcEbv6L69YV z+RvU4Ymc3rQGS8rwTpcYnG2XsKlpDI+9E1bb6knvCe0si+Cl09HxyC/IsCPMFR7yeg4 QdXlxsOU2uzAATT2CaOneRjCM1NKtimERRsYZImR8ofCWQwsXX8uFLGO17ShMqQ4oCUP WJLseUDqDxItU3k4aHNxoMO/0Pkqv2QV2TW1bFPMAOWS8rjkBYDXIv3sXYb8XAL79zWk oKaQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1761736859; x=1762341659; 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=KNfVvIhx701ah8nru3+V19npf0IYFyMM9HJ8zi25jFQ=; b=PqPmQJlSp6LmDzhzgCH4ggw2dhV9MZmyBOleNXpNIbjqL9/JHKlU55jc0McjUcqr/V wgpPghdFpa6Ru82onP+nXyt/k6G4XyFNScr/Uc6FMcoPHth8AlxnFWGJqQi+MHpcnzLD ZXQmBT8yqWuQm6+29Q/puq/1ikPC3xGA06HobeRna/or+cXJhc9xzDKIFqrejrjHIccd /h+fe95iWI7O2q0x2Nu6LqnXqTQgUJkdgndWZDlUmta+QvHNf7Xz9xYmSgM/dFpDsvDc M8UBVVs6a4hc6V+9jT+dwkjCCPwgVZ0e5ZdLBkwmAFmTABI96tuwuNJz4koMVrSi11PD 7KkQ== X-Forwarded-Encrypted: i=1; AJvYcCW6Oenj3sW4mhDE23oDTbzeqmDFCT6xtZsCTubCqI+X3+D6j+mtZ3jlDYPlcKyefh9JH9M+TpZzGQ750XQ=@vger.kernel.org X-Gm-Message-State: AOJu0Yw+uh6c0/6mgHPGG5ulRahee2NLPhVhhmDhfmWNN+T1TMtSNHhe uFI8D3bd3IG/KEOsldxjPUcmIDJlUTqFHxU59BmogI6MhSi6XrOcZFLTitg/3KMUp/A= X-Gm-Gg: ASbGncsSTyTReyGLHpciNHNnZqdL2zvcOZZdUJXRBiND4iQsWf5yM3j7MlSf4i1+cmT Tvu5XDGpINsMtq7uZqL+bEJlw0Wu1qZ3gfHprmJmmAijuRC9D0Q0RFwkNImsl7poUFWBgqaqMzg nwXSFDrwS6K2fOf+MNPgpo2i/gAu+SGvxYgOC5Z8Z4QQrgs/WvtDPp6f4Zr5TxrwIUPTkOX+hdE GRTmBSXsWWNSmiKiXY51wwq804zu+WS2OBp7X4kdaCP6wr2rQgZOEQ1Q5c3jAfiXojZ0sozeo4f rXzsgo+0zQnzzUzf75pTXkrVD4fCQ8edEt+N0BOa3v/qHnUZAuTWGiM/otM2eKK3qSbvPORaKLb HzM927PaywvFBtibeW6nzRTuRqKH4QQDlCidTjtyBWinF3aU3HD2+L3glED80Hh+yg1PLqw== X-Google-Smtp-Source: AGHT+IGkeePD1kd3vgQlhSJySty97Jor3EHVR/WRpsuK6mSgnn8nhqA+ccxY4OWM/uotcxoBrCX6kw== X-Received: by 2002:a05:6000:2889:b0:427:5e3:7d74 with SMTP id ffacd0b85a97d-429aef846bdmr1672292f8f.23.1761736859166; Wed, 29 Oct 2025 04:20:59 -0700 (PDT) Received: from [127.0.1.1] ([2a01:cb1d:dc:7e00:69f2:5f2d:9ffc:a805]) by smtp.gmail.com with ESMTPSA id ffacd0b85a97d-429952df682sm25657486f8f.43.2025.10.29.04.20.57 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 29 Oct 2025 04:20:58 -0700 (PDT) From: Bartosz Golaszewski Date: Wed, 29 Oct 2025 12:20:37 +0100 Subject: [PATCH v3 01/10] 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: <20251029-gpio-shared-v3-1-71c568acf47c@linaro.org> References: <20251029-gpio-shared-v3-0-71c568acf47c@linaro.org> In-Reply-To: <20251029-gpio-shared-v3-0-71c568acf47c@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 , Alexey Klimov 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=2470; i=bartosz.golaszewski@linaro.org; h=from:subject:message-id; bh=O5IzffKw+D234c9Cj7vSqj3rWLQD81BDCjLEL9uRAyE=; b=owEBbQKS/ZANAwAKARGnLqAUcddyAcsmYgBpAfiV6DK3udvEgE5VJ4HmVhvlb/raHRjuJQXuS dZVJrSuRW2JAjMEAAEKAB0WIQQWnetsC8PEYBPSx58Rpy6gFHHXcgUCaQH4lQAKCRARpy6gFHHX cjqID/4+HBzt3N2Gpg3GKc73QKGJTsVH1n4jKs7wsCfKCqFZ7OgFKsj8f3jXrcl7+PFGCI/qE3P NEuI/XbY11Pp9NXJtuZvK/4kQYuFmMvpKd1KeQWyqDuh4vAjMRTVLckmT9nCjXeSMxm0vSI3YI4 06l68Ph5qhGW2O0orSOQ+3VtnrkFZo+jhomLSEPLxT0nZGf7Q+L2LFBTyWMn+OjW8vQIUmU7wJS AIrnaet3+OfcF9IIRXq0gn7EvkJQu+RmAA/1KT/xLsFLh+EzzYXm6HZhVWrsBzzs6QMVrEjzdYm AmtxEqtZPWIMEJdrW3mzzQ3vhC/GEe0zce621cK0/vhIt2AS0Mng690EtRH7sxWlxwRZ71QH7cB cXfCEJHLNfDVzyd8NK+mSjehpzzlNcnvDIfWrjwIQukYXlk/bh4ZrdS0Q2q65jKhmog9Arj+bXl PLpSe+TGkCXrlb4wkIA0LOm10tqd4PbNwazFwFZB7EIrbEJbDdOy30p/gdy8KmHTzp7USMLJimy BxLKVJj8DcagEWFId98URp1Ckws2hpH9vwLm6jJrMFSQrYaVM5ccCFDwscpOxDXOxuXIZeoBZ1N Bs3Tj8B3kE7gvGTYPLtsmX2qnfYx1A/0iUmbFy/WiEiBHpjGEyc4o5ETDEwWJvxQ1cxYD/XwDZ/ a8DRV8ViLKm5GZA== 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 Acked-by: Linus Walleij --- include/linux/string.h | 18 ++++++++++++++++++ lib/tests/string_kunit.c | 13 +++++++++++++ 2 files changed, 31 insertions(+) diff --git a/include/linux/string.h b/include/linux/string.h index fdd3442c6bcbd786e177b6e87358e1065a0ffafc..929d05d1247c76eb9011fe34250= b487834b2d3c9 100644 --- a/include/linux/string.h +++ b/include/linux/string.h @@ -562,4 +562,22 @@ static inline bool strstarts(const char *str, const ch= ar *prefix) return strncmp(str, prefix, strlen(prefix)) =3D=3D 0; } =20 +/** + * 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. + */ +static inline 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)); +} + #endif /* _LINUX_STRING_H_ */ 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 Wed Apr 8 06:06:07 2026 Received: from mail-wr1-f54.google.com (mail-wr1-f54.google.com [209.85.221.54]) (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 7A54432E730 for ; Wed, 29 Oct 2025 11:21:02 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.221.54 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1761736865; cv=none; b=c2cnrJ8GFQJa8DKMWDWpjDSy/EDgwcysPUoP3CbQdPxAy+h1RgmeW+uECqcF1WkYq/wjPt6LGUvnDuPMOfJgKixVmsJO7WYvK3aqB6OTUF/6tr28w0sN0SK/nFcdAGYAL22zk8hmiUZHJPbxOD9PVEnrljm7KmuoJqXrHndrVL8= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1761736865; c=relaxed/simple; bh=khg1xFFDM2akAOOkxLyacg/lV+HQFDhET/KCJgZNRN8=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=AWTUGyVuynpie0A3/KhThnWSxKCHl0HlIK6DeLYzqwUtkDVkzOQrCZPSN9WVRo8I8aLkttjDroRvqmmc6wkfD5+YC0ALQH1VIFZaD4V3zddpPrG7a7xqdT8hztymHy+HCm8F7uDalCnEcFIK4+WqkdCzNq+HwnUJxhImWXWZ+rM= 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=RmIjtjhx; arc=none smtp.client-ip=209.85.221.54 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="RmIjtjhx" Received: by mail-wr1-f54.google.com with SMTP id ffacd0b85a97d-426fc536b5dso4923089f8f.3 for ; Wed, 29 Oct 2025 04:21:02 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=bgdev-pl.20230601.gappssmtp.com; s=20230601; t=1761736861; x=1762341661; 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=1lIU4oOnd9wxauWH3/Fw9rcysB+ICjm9HLPuh90L95A=; b=RmIjtjhxtCq3olEHKY/9W5iPfL60X4k84njdNTEwi0bhc/K4Td5l0zu99KzN8bwCyf Yssa39t/aHH2oUdypXqIxUNfVn3MxD2fvgfgOS6a4OJLZxhgmT5ilabBkFDhcetPahbU 3a6y7+lU5R+BXajqsFTL4N0eVCn10pIYfFHVlodZjaejsMg0Y1oE9F9eYwEXKcfvaPcD yg94o1oMAiXp5HXtyiWm32j7gbJEQFouLO44S18SLG4Gc6z/8lWgrQ0jhxU5qgD4VRca FoVi3WIXoDcHJGmvg1zluV+0v7PO4LjXJS4yogLAwXOJf15zYr+yJ3O+OmvhMTTQBqkG lU2Q== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1761736861; x=1762341661; 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=1lIU4oOnd9wxauWH3/Fw9rcysB+ICjm9HLPuh90L95A=; b=nTBobMKDXa6fSK1qXIQuKdkrWG0Nb4S0rmxx0T7HxZb4Ct/Y9tjBOTn2l7Ejg6BWVa SV6eSzKkBSCU6dXTKS9tCrDZR3BtTfunxnrE9kRq9UdbTDqy32wIVo7TBUXQeh710xYT WSiqAh6QTeMRTtn9O09VYRKq2ATDl/BujSaSnaiGDngEgE+NbwVvjaO8rde53KO2ivmd sJFl//HpY7vI7sdxHrE2VWzm1zrFN2oy7Lj4VXngiWaG8+IZjrnNEqtDG14K9y3RR+LN f6YT1G5qChtXoltjKendB4Upvl9Fwivdz6b/t7ts8UYOaQn/ERSSYcWcYwWS0AAvCFJ6 iq9Q== X-Forwarded-Encrypted: i=1; AJvYcCXJVVbtQhIbzJidKeh2WJcX76jN1Y3ECIrWDMLDn8U02qJGsCgQEu5UtDb3dbavoA0SBB9OihgJ3+FGc5Q=@vger.kernel.org X-Gm-Message-State: AOJu0YwkDofpZEevNbzuQ3GbglOKBwBw5Kf9HAiwE7TBo0xtHgruCfyQ UgSKU1RK5IbbnNi5D++G7ZYuoFnx/iXuZL0WXmHCJvprx6Sn/47tkLEFMHqFGydHyhI= X-Gm-Gg: ASbGncu/55h/xJO+h099jwlJUCbXw3l2jRRdBq2hhJZ7MdGDwUxdSMtadVjae1Rg+7h jUjlX1EAdVvZJIEIyPbB6iNm0Uev0FZVeUsBdLG4RXpK4JvReAgiQQVJd3UX80nFhs+P7xzBalO 1bpmJa7kDxdzrM8WQpOZfs2w0Iyc/eog8uxEXh1oT7g1Cmr3D3DPH3oRu/lngbLtCBWfLvLHb5S W7aYWpJ0rMWl3SoFmHlDqwQM1DjwQyVpUhICox/w5QYiEFUAjDIHYC8NKRoM2tjUHwzD36WHtgX oUjeZFVqHr+FGtmOucth6c3V9Go7ewoXSdl1gXpQmek04B+U9lbRzj6FobAANzo0yqIhGax9xGw xJxf49rgPOfXAMBKq4N5mcl3REC3R6uCscZ2pUL/7syEKY+VX5fWNeuTjw5EAmbW8z5VxmxRO5N ztS+Rf X-Google-Smtp-Source: AGHT+IELysTe56E+mhoHZ7NXstUIW6f3UKmtjVO8ghC70j+DW/TkQAucQOrY5XE0HuDLOQMR9DoHNw== X-Received: by 2002:a05:6000:1867:b0:428:476e:e0ad with SMTP id ffacd0b85a97d-429aef81bbcmr1726436f8f.18.1761736860830; Wed, 29 Oct 2025 04:21:00 -0700 (PDT) Received: from [127.0.1.1] ([2a01:cb1d:dc:7e00:69f2:5f2d:9ffc:a805]) by smtp.gmail.com with ESMTPSA id ffacd0b85a97d-429952df682sm25657486f8f.43.2025.10.29.04.20.59 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 29 Oct 2025 04:21:00 -0700 (PDT) From: Bartosz Golaszewski Date: Wed, 29 Oct 2025 12:20:38 +0100 Subject: [PATCH v3 02/10] 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: <20251029-gpio-shared-v3-2-71c568acf47c@linaro.org> References: <20251029-gpio-shared-v3-0-71c568acf47c@linaro.org> In-Reply-To: <20251029-gpio-shared-v3-0-71c568acf47c@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 , Alexey Klimov 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=e8Z3nS5BNhORSph6UaHIgaZHRcPU9qQgBhb27hulPU4=; b=owEBbQKS/ZANAwAKARGnLqAUcddyAcsmYgBpAfiW4FA7llKfwCZoWb8G15eTM+Wy2jJjYF2bu 3ooeffD6huJAjMEAAEKAB0WIQQWnetsC8PEYBPSx58Rpy6gFHHXcgUCaQH4lgAKCRARpy6gFHHX cjYuEACaqpLISq4p8HrYrIb2+Rq8Nb5ILjV+P0hFXGHSWmJC1wjp0nJB2q+9ru0xbOxMWwtW/Rp HW4WVkKe+RFWNbdMb9jzaXp39XJvoXW2bNC8pMJcqH12jbX3+gYpHmUe5uVwilYz9qwxIhRbMip bQSbDMYxRxK/k/jsxUIxGDKzgFiD5nFCRDva0xP4oHly9vkeMQGzgkQwE3v7lxjzBWTo8KNCOMW 2R6Y/Z+eGc+qU2hHrAa60nnOkwBkaS/yEgpiLp+gnBwYURCkMcZMR6CfJ5kLuNvaX6F6aNRbUV5 0E5E3mPawJcF9EpW7UmjFRA240Pq5qs4LbmQy+24bqeZoF3AFFGyGb4F5pISWqsTARmjXJKrVJl mAzN6nRo8z1fPDRxUpZTCxr16WdZO5jvvjYltdIQ7rzduTGR3xiK0JPSK6XjzKGxMQNtbnP8sLt XK1LJZxGOEtEHQitBbf476R8P+DpKmTJz5uqIzYDk3Z+hIceObbngk687GDaaPmO7bjz9mDcsnK yDvbBQKeDs5NoDC1jn/oGqAsKdjei8JS/3auZOUaPGcueQVKL34E6xR6gjhNRjdNhSC3b2zxOor CLMRY0amk8PsuF1e5VnsqJ+aoPTLJT/y3r9XLgmvgGUMsqjFHidM8y6QyR+euKXB9P0jPGp8Msa dnvUq4A/hNw30qg== 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 Acked-by: Linus Walleij Reviewed-by: Linus Walleij --- drivers/gpio/gpiolib.h | 1 + 1 file changed, 1 insertion(+) diff --git a/drivers/gpio/gpiolib.h b/drivers/gpio/gpiolib.h index 14e6a9807a89da6d7c6594a0a2de5f5032c49e0d..c9de4bb10584206f4888c0f2846= 8762a3680aae6 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 Wed Apr 8 06:06:07 2026 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 C3A4132C943 for ; Wed, 29 Oct 2025 11:21: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=1761736870; cv=none; b=MX+5NXH8CHJQKxH0v5rmcPmOb1e1aYn50QU8KqXQt4lupH3u+BwWSosTBTunrNYGTYglvpkn61KyDPGj740GURqmqMYzAQcRvcm13qI03JAVM91QPXLz07xNbRnnmYtAfmUoEQk9C/8VH3I3chpY9kfGjuLlev2PcXr0ATnoZPg= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1761736870; c=relaxed/simple; bh=rjoPs9vYH6fMjhTy735Fj2c2+FoHgpzHgZ4g41LgYKw=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=Wx4w9ijZuQQUc81a3x4KeZa7hl67nqUZn7Ax5nhFCHPia0SM1H1NVJr86YbCFMwe443G90/PdiW7Yplt4TEiQyQexiuY8qgf9pl3OYmKcFIvPJtLPa5aK3z+ORcOfY4YEZ5oh+4r5DePhyCGZTvS7pZbaKviIDS+JujBcK4Z1lI= 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=I9QXnaDS; 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="I9QXnaDS" Received: by mail-wr1-f48.google.com with SMTP id ffacd0b85a97d-3ee130237a8so4695648f8f.0 for ; Wed, 29 Oct 2025 04:21:04 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=bgdev-pl.20230601.gappssmtp.com; s=20230601; t=1761736863; x=1762341663; 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=M8mxbduNvH6lpNLoPIFcs/ilcirgwYuHIBprjLVxIoc=; b=I9QXnaDSgyOWZbQUdLZD8CeDMb0joN+Y68WePJm4cwZ2WnIPWeRAvj2F6T1es1qPKN otqLErUJDP+YGKPeIQWG0JsbajRhHtf2fWrMcd2G853k8gxZ8cIqTEYmBcAeSrO05KXV cXT4bEqCVDGGFhX9CLUnrxnVSvqJMnymbp1jPRZhQoyEu6jQwujaZoWUW1adBWeWItQz jCPXppuXgAnvAFVxT9UoBUgx9p32GPbClrXQ0JkvTdheWZSBsQ+Xy/izOcOqc7FyCsv5 wlZSITdgv3Cx0q0Dh1xAr5miAE40DC7SWBSOxMgmcRw3zOJNQWdqSb6fqhWTxtFdGjEJ 1/Bg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1761736863; x=1762341663; 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=M8mxbduNvH6lpNLoPIFcs/ilcirgwYuHIBprjLVxIoc=; b=Dfd8YfnzyC9zeuJShhbaaKVHV2iWS/soSnd5jS51Pp7tOV+UovYhYXPlg2QD9qAxV4 vKrTQn6KPyQv8HjT3coUml885CbAyxPNAfwyp31mRXiKhK9Zso7QCDHZ5cq2JvjTzGkc F8RJtMXKfq77fvq5qCUZZBW4bQdSZabW1puQXEiFk5DIufBMreHtU9YufRvmYj+G7SQD jRDhuqS1L7q/AH9mXqbgWzrp4bYhBadw4r65xqm209lrj3r/yNy+jS28spBIlpNJZIpb FmjX0e218+stmec2u836CZHkQM0Ga9ZUGr6zYrJU25hKO6qE1ZNO14HRmnU3ElsCowYd 47RQ== X-Forwarded-Encrypted: i=1; AJvYcCXqFPwm1AT6O1xz0cIr5/Cqs68RLoqFe8CZU9wqpxY7NUhA5eF0KwGKRtj9xPTiK2MHegR1A+Ovay+r7d8=@vger.kernel.org X-Gm-Message-State: AOJu0YySswHEx3Qq6wR481pWi776N9EsQmyOjjxTUh6oF+1KeXkwo06s P6Huzc9RhFBIgQgiX+jUMXWpOlEyoEoFGOi4C/LHJNFM/zrEvYzcG0RQx+DjERjsdrg= X-Gm-Gg: ASbGnct3Fa5dT1TeIJPiDNQJi/oYwDA+wtBBCLqJO05sA6tSZu0Qq6fRR/HGIwA12q6 ns1iqM0pXwxVqHjqqMow9rVwHk/NIxqye9IhxtcVrUpyhaZXHQHk3Q2lzwoG7xFa1tAIGAFBh41 ojzD7WoHKV7rhm2DJ+oM75RTMIe1YqNVMGx0tpEbD8+IHSpOQ1XDlHGHK5Alu7fkW87T4z2nh7Z u6u13bInSdb3GfsHy0mRNlrJzpmLpBdwYhQs4lwhn8kIbkYqibTIYdGY7Ybybe868CAS7khiWvI A+tFKkMBc0rRuS05CdqwR/ron4nzv1uu/vhSq9v542rDhufKm1qowfbL7azeX24cX2VvNduEWz5 0wE6IIbMtV0Sc6A117Q6EZKKHYglQ70X0MYobHA/HPhAFcjujAgEu1ZpR7K8yBkVNW8wX6g== X-Google-Smtp-Source: AGHT+IHU2ISrLDQBb3L8Brh+RIzVaFE96XtzlLEHiQV0xtfoqDYTCeOQJJvAIzAk1fnj5RgZq9kT0w== X-Received: by 2002:a05:6000:40df:b0:405:3028:1bf2 with SMTP id ffacd0b85a97d-429aefdaa13mr2142472f8f.62.1761736862503; Wed, 29 Oct 2025 04:21:02 -0700 (PDT) Received: from [127.0.1.1] ([2a01:cb1d:dc:7e00:69f2:5f2d:9ffc:a805]) by smtp.gmail.com with ESMTPSA id ffacd0b85a97d-429952df682sm25657486f8f.43.2025.10.29.04.21.00 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 29 Oct 2025 04:21:01 -0700 (PDT) From: Bartosz Golaszewski Date: Wed, 29 Oct 2025 12:20:39 +0100 Subject: [PATCH v3 03/10] 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: <20251029-gpio-shared-v3-3-71c568acf47c@linaro.org> References: <20251029-gpio-shared-v3-0-71c568acf47c@linaro.org> In-Reply-To: <20251029-gpio-shared-v3-0-71c568acf47c@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 , Alexey Klimov 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=18873; i=bartosz.golaszewski@linaro.org; h=from:subject:message-id; bh=jMw/KZNWJRL5/YXJB7reY4XkP4bv1KoSMhywQNxeGkM=; b=owEBbQKS/ZANAwAKARGnLqAUcddyAcsmYgBpAfiWcOFs00jLGgHKCTRJrtbnuwFVY3DeQaIja sLXRF9VhJyJAjMEAAEKAB0WIQQWnetsC8PEYBPSx58Rpy6gFHHXcgUCaQH4lgAKCRARpy6gFHHX cvPcD/sFADFdEeR+X8/9gJqlErHLAEYalDDueaOTazWPi1l+giMYEHouS3MbFEr4SzivKsIpPSH tuxDMWEF4d8WpM01jZ4D7aMlgjS23fex+fh6Kg8k39wiY1I4r4+n2ZlTdIsowijrFTymraWMXHQ bhDKJWXro3bPTYcCbdPXCMv/neIB7Aavj7GeHJtuVPU+p/r7ECC4u4+fpoE0wezniexrTE1kCkr qbVPKW6/EmF9yvnZsWjQcCDb5ENlLpxg85Q6rHf39uailFv6o44s84PNPvm+JG4SCLeNWakMGAr Hf3Q+dK80tpyzZYYtdwdgllmDWaBsHyYGuzLC24smXSXU4RvgxuBo7lbxDHu5NGm7/koTjXCSpJ pqhGeoulxrlBLNjjCUwXCjWVknw+24b3UqFAmTUzP4WyLy39dEhgzs4Kakj29gkiTPd3sR4Zj2a vSM0yI6H6cKu5Jd72icPIRIsnnNe+wJf705wbkewslwACHQ69wiOcQtYseQhIcIUOeCH3hA13uO f43GwGlky8wwBmIphIr+MEwppsVnI+AWaVnj2YdsNiE4BBEVTdV9xHxoLW4jOWJC2x3IBa8Z6Tc nBbfAFCIPfpGqCHWze4HqAjg7CXaBeZjUxN9A1E6IATKjjufrEIsE9ADOBtJrRoG3Q98rtftSCE AjGffoGSIed1LSA== 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 Acked-by: Linus Walleij Reviewed-by: Linus Walleij --- drivers/gpio/Kconfig | 8 + drivers/gpio/Makefile | 1 + drivers/gpio/gpiolib-shared.c | 540 ++++++++++++++++++++++++++++++++++++++= ++++ drivers/gpio/gpiolib-shared.h | 71 ++++++ 4 files changed, 620 insertions(+) diff --git a/drivers/gpio/Kconfig b/drivers/gpio/Kconfig index ce237398fa00eddad49afe995accae3abbb4b2cb..f90b4d3e77f7cab46525b7adfcf= 114a21d276678 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 DEBUG_GPIO bool "Debug GPIO calls" depends on DEBUG_KERNEL diff --git a/drivers/gpio/Makefile b/drivers/gpio/Makefile index ee260a0809d36cd07987f04e0ef17b05af764214..48f309c764e3286c23dbe604be9= 33f7180f0b89a 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..56b9b03cbb6dbcdf095a656fc36= ff321770035da --- /dev/null +++ b/drivers/gpio/gpiolib-shared.c @@ -0,0 +1,540 @@ +// 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) +{ + struct gpio_shared_entry *entry; + size_t con_id_len, suffix_len; + struct fwnode_handle *fwnode; + struct of_phandle_args args; + struct property *prop; + unsigned int offset; + const char *suffix; + 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); + } + + struct gpio_shared_ref *ref __free(kfree) =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]; + + if (strends(prop->name, "gpios")) + suffix =3D "-gpios"; + else if (strends(prop->name, "gpio")) + suffix =3D "-gpio"; + else + suffix =3D NULL; + if (!suffix) + continue; + + /* We only set con_id if there's actually one. */ + if (strcmp(prop->name, "gpios") && strcmp(prop->name, "gpio")) { + ref->con_id =3D kstrdup(prop->name, GFP_KERNEL); + if (!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'; + } + + ref->dev_id =3D ida_alloc(&gpio_shared_ida, GFP_KERNEL); + if (ref->dev_id < 0) { + kfree(ref->con_id); + return -ENOMEM; + } + + 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(&no_free_ptr(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 void gpio_shared_adev_release(struct device *dev) +{ + +} + +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; + adev->dev.release =3D gpio_shared_adev_release; + + 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 ?: "none"); + + 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); +} + +static struct gpio_shared_desc * +gpiod_shared_desc_create(struct gpio_shared_entry *entry) +{ + struct gpio_shared_desc *shared_desc; + struct gpio_device *gdev; + + 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); + + return shared_desc; +} + +static struct gpio_shared_entry *gpiod_shared_find(struct auxiliary_device= *adev) +{ + struct gpio_shared_desc *shared_desc; + struct gpio_shared_entry *entry; + struct gpio_shared_ref *ref; + + 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); + return entry; + } + + shared_desc =3D gpiod_shared_desc_create(entry); + if (IS_ERR(shared_desc)) + return ERR_CAST(shared_desc); + + kref_init(&entry->ref); + entry->shared_desc =3D shared_desc; + + pr_debug("Device %s acquired a reference to the shared GPIO %u owned by= %s\n", + dev_name(&adev->dev), gpiod_hwgpio(shared_desc->desc), + gpio_device_get_label(shared_desc->desc->gdev)); + + + return entry; + } + } + + return ERR_PTR(-ENOENT); +} + +struct gpio_shared_desc *devm_gpiod_shared_get(struct device *dev) +{ + struct gpio_shared_entry *entry; + int ret; + + entry =3D gpiod_shared_find(to_auxiliary_dev(dev)); + if (IS_ERR(entry)) + return ERR_CAST(entry); + + ret =3D devm_add_action_or_reset(dev, gpiod_shared_put, entry); + if (ret) + return ERR_PTR(ret); + + return entry->shared_desc; +} +EXPORT_SYMBOL_GPL(devm_gpiod_shared_get); + +static void gpio_shared_drop_ref(struct gpio_shared_ref *ref) +{ + list_del(&ref->list); + kfree(ref->con_id); + ida_free(&gpio_shared_ida, ref->dev_id); + fwnode_handle_put(ref->fwnode); + kfree(ref); +} + +static void gpio_shared_drop_entry(struct gpio_shared_entry *entry) +{ + list_del(&entry->list); + fwnode_handle_put(entry->fwnode); + kfree(entry); +} + +/* + * 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) + gpio_shared_drop_ref(ref); + + gpio_shared_drop_entry(entry); + } +} + +static void gpio_shared_free_exclusive(void) +{ + struct gpio_shared_entry *entry, *epos; + + list_for_each_entry_safe(entry, epos, &gpio_shared_list, list) { + if (list_count_nodes(&entry->refs) > 1) + continue; + + gpio_shared_drop_ref(list_first_entry(&entry->refs, + struct gpio_shared_ref, + list)); + gpio_shared_drop_entry(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; + } + + gpio_shared_free_exclusive(); + + 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 Wed Apr 8 06:06:07 2026 Received: from mail-wm1-f48.google.com (mail-wm1-f48.google.com [209.85.128.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 3EC193314C8 for ; Wed, 29 Oct 2025 11:21:06 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.128.48 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1761736869; cv=none; b=AcQl4OEk3Raft+r17GGH51NpP+aYJ+V9MB+X7rfFdgpEuxsMbIXmunt4IQ+HCFb6Ses2i4BENKPSVFv/TWEo9XEXdLqZ3u8HhitHOsECfnNZeHkXMkCwN4hI34ydN6jWs2IrzfwRxnlJbblQNf6K01NxwnDJ8ciuTPbPGBbnmH0= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1761736869; c=relaxed/simple; bh=wEklMGXUGhiw9zk0F9lYR7DBwNDYJUEBreqBM3YOjR4=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=GhElfLS+CmBYvb+QVN9RDlohqT/qm1NFDxorwYCFtqfrAQUzcLydwlp2xkRyD3JAgapWf3HMrFbkLUdie1Y/3gljDnae/vkXo8yhcuJe4mr6nzE9F5gQuatkBBubmBHL1NiZS+9E9nM13/54/RCdkMnhQvNaW25nPhnyDZX3nAY= 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=RVsVFQYL; arc=none smtp.client-ip=209.85.128.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="RVsVFQYL" Received: by mail-wm1-f48.google.com with SMTP id 5b1f17b1804b1-475dc0ed8aeso39544285e9.2 for ; Wed, 29 Oct 2025 04:21:05 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=bgdev-pl.20230601.gappssmtp.com; s=20230601; t=1761736864; x=1762341664; 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=bzAD0cYTYlmz/0N8KICWQ9Nbs5w1QtlOIL1Twm9Y/FE=; b=RVsVFQYLre8CTY/AEnh9wL226XgIAyGU5KoCOCOTXy0i0udMyhj+Q6Xt2wd06XKfC1 tbtMi0d2mX2M8U66A4ndXs7UBZ2lT8a/LsAKLWy+if0gkEnoe5gut8rB/2PgSCS1QOUi IwTnNJqpitE8PZLO58OZ1yAvki5mBMHdZMC22BFaLKu6zCjM36cXAnKpZKdHfnZlAW/3 bNGBlbX3Qn2Ff15PJkgjbA4DDvDmwRjrKaIaKZEnvWyZi6k4A7gh5SMNoy+A6Jt204y8 eMs7QYcvE049NT4Dw22UJLFqu4ioeFx6lzParpjGqPeHR79+DsYzPssalUNu9Q8i8QPh v25A== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1761736864; x=1762341664; 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=bzAD0cYTYlmz/0N8KICWQ9Nbs5w1QtlOIL1Twm9Y/FE=; b=rjta4eEizhSbOzEY0s2frCGL0W8JkScekFKtBuZUBCsEPsDLkaJqZYl+xFRzsswvzj i480n/4kbcE/n4VzNjbwLVxqEOBwCoxXhOzUoeODcCeDOVdkXhWatP2wRY9hEQ3jCFAN 81HK4AghASOTHuKJ9ZBYDK2ucU3AlFjG/NeUAprMvuN96tfuiVW4oHukYuHxF+T9aQuL iJw3HcW7gM2XDgWRBLaBQ6mXUUWyE9iLattv7TA4aa4igMHTp5DIQjAA0yuDUUDMv9IF 4l5b9bc3TBVq7azvAR188B2ZSmzEWrsVken6EiLH5I6obONH+/ZMR/McpKaC4cMRNb0K h+4g== X-Forwarded-Encrypted: i=1; AJvYcCVdLhpIR2OqfLaYtHLV6tIU6Tm7IXjqyYKOy5mclmWcifyb5td/xLaB+rM+csgBT0fz1Twcv8JwLe9Gjsw=@vger.kernel.org X-Gm-Message-State: AOJu0Yy9mPfQVKZDhjFVEmtWCwchKB1FbQv6QlnWsZeFJQYOSdMH94+v Bfps8rWKEm5yD7qFRATfr99QfnMEfQs2BcXMVa2h4gQ7hhwgcw8oE6jhx45Q1Aklk4M= X-Gm-Gg: ASbGncuKXTexDTkRHlIuF0vtJGQT0LRIinedjpvV7xbGE3/DitA4M1qQXAyLiVTuZTp 00V/TS9BVOtWgj5qbekAJmT4wPdPwozDtufZwyJ4DGZwOaT/mxgon5QvRQFNEkUmqEa/GIuMEb5 ej/CoibGnKYeU3jLoPk6qvosBhRvbiLF8jwA8qDTDjGen8DXB3wIU5Z42olPttl1XxRY2kxJ29z yk1pLHzu9uLdNGYljpMtv7EYP9x4iLg8e7A+F+gvJ13L6/bOnSdVG7GdHE57zBUo7kne9Gs5k93 utAVDk6MuuOaapLLtNlTwkiQgZXYbpjnrIvAcPlHAv22OvwoPFdUMwJ6Ymj0E5t+PqwmY+BZCGH o3Cb8Aoa8mcw7LQQOGaMHk+mLQ1hcgb9kuQQAUFm/b8AYB98SnVsKHVqghhRkprMycMULpQ== X-Google-Smtp-Source: AGHT+IFepT/g0mGDDZu27qox151T4Ope3H6XWzZKOv8YtbmF843M3u2gByG79k7r47GrguQ+Zcr7oA== X-Received: by 2002:a05:600c:64c4:b0:471:15df:9fc7 with SMTP id 5b1f17b1804b1-4771e1e008dmr21333525e9.26.1761736864339; Wed, 29 Oct 2025 04:21:04 -0700 (PDT) Received: from [127.0.1.1] ([2a01:cb1d:dc:7e00:69f2:5f2d:9ffc:a805]) by smtp.gmail.com with ESMTPSA id ffacd0b85a97d-429952df682sm25657486f8f.43.2025.10.29.04.21.02 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 29 Oct 2025 04:21:03 -0700 (PDT) From: Bartosz Golaszewski Date: Wed, 29 Oct 2025 12:20:40 +0100 Subject: [PATCH v3 04/10] 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: <20251029-gpio-shared-v3-4-71c568acf47c@linaro.org> References: <20251029-gpio-shared-v3-0-71c568acf47c@linaro.org> In-Reply-To: <20251029-gpio-shared-v3-0-71c568acf47c@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 , Alexey Klimov 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=12071; i=bartosz.golaszewski@linaro.org; h=from:subject:message-id; bh=nMwEBRFh4XOPjHIiaJPyL/IGQRbGQ5r+fPXFOtJIq4M=; b=owEBbQKS/ZANAwAKARGnLqAUcddyAcsmYgBpAfiWkyxmed080sYivuvosfShdCG2eUvNdzlvu 35d2InUDMeJAjMEAAEKAB0WIQQWnetsC8PEYBPSx58Rpy6gFHHXcgUCaQH4lgAKCRARpy6gFHHX cixfD/9jv6RbhPw0wFQ1c1KsGtJnSyyUFcV2FyPivD/wcVtheWR8AE0GIB/Ojrhp2XRqFxYYPd6 ESdFp8m2TALnvNpPIzFIyqJmp7qxmAHfATffBPy1EFbm7p9ZgSMIlpdXQSVgHsvgfF/PyhNNwT/ g3umY2WWtU909Zg9zQgTEfsvqzTEolxe/DC+tTot5v1CNZ+tWzxOCHm8GSqPKggzMG9BWc93HLe gM9kLf6MxqjLrSXvRG1t5j5XcC8TyVWVS3+2w9pFTxW5vbfROLkZJPsJRXoO7tccdjONaUQcMWt LbXbFzXVa0ddSnJcwyn5HNFgc0vHpRMKMMMNbvmTSOtnyhJYU96p2lI7xGTyuiTscYgRLz6MW8y BO+vTg62YhPfvYRSDuHqePUWwnVDmlOyvaACmR7Q476J4t+g+/tlo/VbY8I0bThsn3rpZH/tRJ+ ElW3PS72DXaBWDzrZEJtQCYq+bc/PfyH662mHQeL4ym+Jm+jHZj3ULcPKny2xBRvcnehhm7+n1e lptOeSil+3LvecWpU87kIdcApGalrHQfqpNKZ72rBjWJhKYasfZgBqu3L5roeQmt+xAwaE2BpYD 2JVvjmWxwZJ/66LJn7rkiCdgFMQ8d+sl+84g3p3TOuMop4xQkyaDLrLsmY0y+DNHW39zYNZYI6+ WzgOPqxRKhq1rcg== 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 Acked-by: Linus Walleij Reviewed-by: Linus Walleij --- drivers/gpio/Kconfig | 9 ++ drivers/gpio/Makefile | 1 + drivers/gpio/gpio-shared-proxy.c | 333 +++++++++++++++++++++++++++++++++++= ++++ 3 files changed, 343 insertions(+) diff --git a/drivers/gpio/Kconfig b/drivers/gpio/Kconfig index f90b4d3e77f7cab46525b7adfcf114a21d276678..f910c20f0d5d7771f7f8f3d52ce= d7bce413d24f1 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 48f309c764e3286c23dbe604be933f7180f0b89a..2421a8fd3733e0b06c2581262aa= a9cd629f66c7d 100644 --- a/drivers/gpio/Makefile +++ b/drivers/gpio/Makefile @@ -161,6 +161,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..3ef2c40ed15229074052eda93b6= ee56f0a2bfb72 --- /dev/null +++ b/drivers/gpio/gpio-shared-proxy.c @@ -0,0 +1,333 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* + * Copyright (C) 2025 Linaro Ltd. + */ + +#include +#include +#include +#include +#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", + str_high_low(value), 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= with value '%s'\n", + str_high_low(value)); + + 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 Wed Apr 8 06:06:07 2026 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 40DC93321A4 for ; Wed, 29 Oct 2025 11:21:07 +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=1761736871; cv=none; b=FbC7p322ju24VCf9N+HaJE6Z4pLCuf052UDvytl9YBr4G1W5tV3M4oVpdyDP9QC0fESoh6Lmowt9I6qBk3ekUPs36D4EIWcqptmaa2Jwi2QxjtDYzatKO6kNIVwjnWN6gB+mxYUGHiNLL53oXrwEYPbBFMk+pSEB7aVW1iijpKc= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1761736871; c=relaxed/simple; bh=QOIVfl+TJ+NysL33d9l/tNLpZoKFZVt0t++/WjOc0Gg=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=nKGUqlFSrMHdB9AgPTEOTXmIV835DXVb5XfHNsMj6PKRhFLG0emQO9gpU7pny7z3DvUUFnrwr8ysWC7uh8YZFByqJxRgE0IEg3f6M8rYee4anagD1LWf9yWeA6T5+PyFknih+A2z9ejjf/d5DsrGc+3jvBU5tFK3IvEmBsC8Rok= 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=AA2VF4dz; 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="AA2VF4dz" Received: by mail-wr1-f48.google.com with SMTP id ffacd0b85a97d-427084a641aso5316389f8f.1 for ; Wed, 29 Oct 2025 04:21:07 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=bgdev-pl.20230601.gappssmtp.com; s=20230601; t=1761736866; x=1762341666; 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=jZnk+nYLZl4QMw6EhjYCVYds4/Rzm6O866RrS4AjrMs=; b=AA2VF4dz3g7RvBQTbAkfXUBpEzJZ7qmy/IXa6wtQiJCcIlDT/IMmdaelrz3fpQ0l55 ficK/AnYQgZccxQnGSe5OU81hKExBtoTaK2S5IkZ2mG/uiW6SiU4de4AI98FQ4OpPGvk 3fkOcgt4bUHHiznzJ6eFREUUQ5xUjNkzipatzFBhlKG+rjVU1DUKh0lWzzsjQ2Ja5dfE OoZQwW3VQvz6pugXZI3wZ2ikjl6p70i9aHr/CjzV2ovs7a4DrlibVN1ZJLKkYflPD7gm 1kVaCZgWMkq/NbuEDY+s40cpzZJFiDgjR2KEGLI8wexYc4IUFxy5kbGWdiLDfUKE/Jru 5DvA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1761736866; x=1762341666; 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=jZnk+nYLZl4QMw6EhjYCVYds4/Rzm6O866RrS4AjrMs=; b=H7rpFCou75t6Mjz/13K20o5j5d41NlswThWa+q9Nbroga2X8Qp7nu+icoEgpObHlXX xR0eacpb8DE2kIkFlFpA6O4l/GaGxy2V+9CePaSE1Ni2MvVSJgbNDLYo+WaLSlJukO5C cdxW9D9lIpvMqOus2KXcbQkwVsXeVGRIrUEl7lz7ogU0txdzeroTLsBUTLfbzunde0qV 6+6Pq778aTx1JcbkyK4okfZINYcGEs6gVz/9Fa/09kEHGEpNqb+BtVU9VzEuC7UF2pQb FGbTertVKNZ9n7+9Hrz1x8vRPOAVBXsqKXhXLIVddv3vCadI7kjqsPkiNA0n+d0R8qe1 btiQ== X-Forwarded-Encrypted: i=1; AJvYcCWtmMi5S5Wii324dapFNqfDXltxzSUkFvbFqKV1CE+3XtuOsIIT6JOOkTrg4IDRDc06dRHPQsQmZS5nkYE=@vger.kernel.org X-Gm-Message-State: AOJu0YyYiughI9VdHLqkoFNz8yr6G8bOdjhgkxP+TwNbRb5ZGkSBCylQ sBFfci0k4MTeSD0VGG4VkDhwAPDw/LGCniaQIgm+5CZinbsxtfxHOn7M02cWR2bHCtQ= X-Gm-Gg: ASbGncuCWdKu0UqLRLaWDiPHlKt/9qIGFN/H1wH4MwaN6iLVNJSMTVny0Xv0GSnw5cU 65udAVBFccQIvvyUoP6k/HQM50n2ZIG6g05HtsqrGyUYtNbNLUTNhtYoKq+Wyu0nx0goA5kYWof 2fAnmjBKpH0OGDHvcusuz/Ljza59i7Ofy71vadvrGdmfAMH/kvSpu4D0D95rBbOuMUJqppY24xL uuveRpUg2k18WGQsdG7m8h0rJTtW8lXiZGdzxLV4XbXALHT1W5AYn/pVV3szGHold5ljooXQXPn zVokL+2taTMIS0iVj/uDQ3dslsnB2jpbMMYfvF+54QaP0BVT02uFCtht2WEbY9QIgq99PK/JS4d fUJNjy6aRGqHBFsx6fuRZFkiCBFFxg78zSVqiDiugNE1A+zyQGbiznnSYYRutBU7wkYAxfFzYF1 9S+7xa X-Google-Smtp-Source: AGHT+IEQUECFDEstV6QYZ881rRQLkcezBKVFVx3TzPPXX9d1qB7SalXkzG6fyMdXz4omLQ4r+N8hwQ== X-Received: by 2002:a05:6000:26ca:b0:429:8d0f:ebf with SMTP id ffacd0b85a97d-429aefcce70mr2187907f8f.42.1761736865935; Wed, 29 Oct 2025 04:21:05 -0700 (PDT) Received: from [127.0.1.1] ([2a01:cb1d:dc:7e00:69f2:5f2d:9ffc:a805]) by smtp.gmail.com with ESMTPSA id ffacd0b85a97d-429952df682sm25657486f8f.43.2025.10.29.04.21.04 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 29 Oct 2025 04:21:05 -0700 (PDT) From: Bartosz Golaszewski Date: Wed, 29 Oct 2025 12:20:41 +0100 Subject: [PATCH v3 05/10] 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: <20251029-gpio-shared-v3-5-71c568acf47c@linaro.org> References: <20251029-gpio-shared-v3-0-71c568acf47c@linaro.org> In-Reply-To: <20251029-gpio-shared-v3-0-71c568acf47c@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 , Alexey Klimov 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=Gv6nJIcFpujEIkYYyh8HXEYQVPnSJEXWWrdVFvalF94=; b=owEBbQKS/ZANAwAKARGnLqAUcddyAcsmYgBpAfiW6yvKWgnemCKDMGGGyJIWSPB+dDUrSnYnN Wiel7dmsj2JAjMEAAEKAB0WIQQWnetsC8PEYBPSx58Rpy6gFHHXcgUCaQH4lgAKCRARpy6gFHHX crO/D/4tlrX9yp1WjVs8pqfpRZSAPKctw3sdEeECrsNrR405t6KWbicf+OQ5JsugurdU4e9dEbB e2e46BloGBdTXEUJkOrn1r5rNX4fWzu1+PzqGz0g5xCbwtgxt++E/aGHr9Qt+BbYXmDD1eWSl0X ELqRsSwD0SI+BhNg8c8JYHOka42MroUFrP44E2Nt0wHFxvb3JItYz3Lj+FJ/XCN/UBscAhIg5nt N/SvZu73HDR/C/Kxi2QNMXLBHm4CBdHYzit4n2PO4ExLiNGI34Swsujoq6sv4JMNTop7nwzatqW 0yadz+ifq/TfQZckDcpX6YB+VSyPyvYIGHZiTYz858Hg9ZMeZWzOCQX99neYMIPR/ncDxw0MaQ5 1u98lJwk93IDhKU2bdn68hUP4XkDQPRrdiNNKaSi7nkMFSAYMKf787DhbEfFkP7IAkx2gzTPq2Q Og3LL6Kvc8e4W/KZBE0Vc+aHNe8nyESm7sAcyZ8ts3Y2nGsAUuI6QJ0s4BLxCqPxWZWjhx81P68 qBRZ6nIi3cpK/shSnOLxW6BsUsA0Za8GP5ZwxdIy01lkH6Bp+pNOnR8Zk8uP2/BjHXdqL1VFbDi gzkJlQt4E0QSD4tx7v88qtkyBrDDQ+35e0utG+K6WWkd2bAEDsdzzGE6G/RsapiIfVmBgJmwQBw TI9kgjbFato4a2Q== 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 Acked-by: Linus Walleij Reviewed-by: Linus Walleij --- 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 a81981336b36db49d899634feafcd9bc25edf96f..c0c0e9370f150c340a7c79dc03c= 5afec64a440f4 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" @@ -1213,6 +1214,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 @@ -1224,10 +1229,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: @@ -1296,6 +1304,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); @@ -4659,11 +4668,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"); @@ -4686,14 +4713,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 Wed Apr 8 06:06:07 2026 Received: from mail-wm1-f54.google.com (mail-wm1-f54.google.com [209.85.128.54]) (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 D1F44334684 for ; Wed, 29 Oct 2025 11:21:09 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.128.54 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1761736874; cv=none; b=FTgTv5yqcXOsNrXQHYZIf3fUv/KphSwMW2LvizfYxvwtxIwYgr4bxL9J3wogA7OW9EerywtGsDFtt5ZW3Tg0nqvkh6q63YNcil6o18uJqQyUP6XeKlnCzb8/sPr7IfXGfFgGIIdcsgf68rHjOxhlG7Gydd5ag0WZwl33rD5Jq48= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1761736874; c=relaxed/simple; bh=MVlKPIvAL/e9P6rRlyzXBZOIkV9VrbynrQLdkfSFr3I=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=a2W5HPolETaU92ehm+E5XWN+NWwSXOKSRsKqpG9FRb/jD0UiraMi4LLxZzrKUYbNj7El6rlH/M/g/mQwzOOBxQ1d2bTOEZgyb5oqfX2i5gPOvjNlh16pThBi4i/coAqAgJ/pWJQVaf3UqJX4LNAm8PSyL6U2RTUTIPRAs2Gx3VA= 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=wHfsyfBC; arc=none smtp.client-ip=209.85.128.54 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="wHfsyfBC" Received: by mail-wm1-f54.google.com with SMTP id 5b1f17b1804b1-47710acf715so18455855e9.1 for ; Wed, 29 Oct 2025 04:21:09 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=bgdev-pl.20230601.gappssmtp.com; s=20230601; t=1761736868; x=1762341668; 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=OwyOQFxKD6v8+Vijfrpb6af7Tgda7juGJv7xRyBxXBI=; b=wHfsyfBCn5RKLEH2usq1Hfh5pPvEMXZXNzOAZWZE4jagDmhnCI1YdkGgfjV+Fo4elr ZYvdVWMLlQPqbMyChkypygDzvbke19XP+T3FUX+OHuUxLIhOTcyO3OCsN2kIXJWkwlOH BFw9x+X0mhF2BMi2a64y9LP2XIc6bQBJHbHn1XQTGI4w4MyjtCh425C/49NpwMaZ4KLl yWA1GJFNRemKq0h1VBVLpCwetwEiJA3poffMA3sGJZjvmp+DumZ6AkBQika199s+vt13 z/SMZtdUOAIgl8qRoBSi5Uao3RECx4zkcFxrefEzr5m0cUHksV6dIO8e0NppKPMVvl4m 1MJQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1761736868; x=1762341668; 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=OwyOQFxKD6v8+Vijfrpb6af7Tgda7juGJv7xRyBxXBI=; b=lxiK+a9gW5Y3y312zR3zxP6XqDjyGQoB4Y9nesXSbaNOfNFDgN67MlaTkoiI28AcIX vVoNqNNHmxAgqc6t/SC2zQOAvnWmWMoM9Mj0bQIK8yjSWg9nPYX3tA87/0uO4J72stkI 9VWLBMvKchUFA7zCfklLrHhMY3usMXYWoaww7VvYvwxpYYv2qQlRvoSyJoxCLC+f7F1Y B5VujyshnEduJMDAal4ec4nNSAtE0cGZmD0Yvqm0rvNoeVR4Oy7MfNZu/GMMNW2YScCs hlSCCn1D6I0NcXppziA/u+aZChkrpOgwiG1L8fYS1sgAwUxOEP76bKfEGfK+b9EZbyKt h72g== X-Forwarded-Encrypted: i=1; AJvYcCU/4XP4Nz/ztoEik/+X89Q/PPx5Bmqc0KfBQnsTdfHpwIiXTfkrqxWOrX70IDhvI2R3cXi+vDJm9OfWf3U=@vger.kernel.org X-Gm-Message-State: AOJu0Ywy19c5I/QM3jtVD4iHr3XddcAFB/dYTKtFa6PHMWlimAL2oMgm dw4jvJa8cJ97mGo7n+xcmWzAKpdzp8x/Ghl2+op2Jm4rm3Wr74XyroALSP8oaceQX/I= X-Gm-Gg: ASbGncviSwpSsby0p8MHDF6YkTJ9qhHKb68wVE1/3pbqIct/CyONwcntKXik0BbscEj SjCiTHE5SzqlNoYQ7RM5QV1Dxm6feXTQl0CduzJQUEJ6/MZkSGclrjaQEWmw9RieS+bkhgpSw84 EWC7t0w2hs/lvZvYLX1hz3ACs4CW/9D9BMdUEBPYwg0uomQnFW4JP9XMhRxPGGkL9wHZJGW1xv7 gNhgopKgMTzgYU5AIcY/Cge6nDz1ZiiMJfCpzpn62bbYv+fvN9hrZzbeUAO7E7YPRe7uhTXA60p 5EBGDP9PGLvTRHAFQr0WbHLPbP14L9ORzzzB/j7zXivHY1n2Z0wo9dZzDWHlgg+gb69uCba4FSS nHPyhQRr6sKhs+9LGQqNuSLfi4W9E7WzzAplXQimwZNIC9zGpD1CfAPKkbEWkt9HzsT4R3Q== X-Google-Smtp-Source: AGHT+IFIp7+UTDG8Mo+34fKN/ODFuhtxQqO8HkLZOExm++avTsEPa/O05hlDIAIwB6f3V1lsHOMS/A== X-Received: by 2002:a05:6000:3107:b0:427:370:20a3 with SMTP id ffacd0b85a97d-429aefbdc04mr2206317f8f.38.1761736867751; Wed, 29 Oct 2025 04:21:07 -0700 (PDT) Received: from [127.0.1.1] ([2a01:cb1d:dc:7e00:69f2:5f2d:9ffc:a805]) by smtp.gmail.com with ESMTPSA id ffacd0b85a97d-429952df682sm25657486f8f.43.2025.10.29.04.21.06 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 29 Oct 2025 04:21:06 -0700 (PDT) From: Bartosz Golaszewski Date: Wed, 29 Oct 2025 12:20:42 +0100 Subject: [PATCH v3 06/10] gpio: provide gpiod_is_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: <20251029-gpio-shared-v3-6-71c568acf47c@linaro.org> References: <20251029-gpio-shared-v3-0-71c568acf47c@linaro.org> In-Reply-To: <20251029-gpio-shared-v3-0-71c568acf47c@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 , Alexey Klimov 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=4764; i=bartosz.golaszewski@linaro.org; h=from:subject:message-id; bh=SHc2LMOdJGlhdyjQkFVMTs07D3cYT7+feKhUydYkGmE=; b=owEBbQKS/ZANAwAKARGnLqAUcddyAcsmYgBpAfiW0Na3G1N5t7fsKNsK2pUTfvrIgTuAwZdX6 A4Q9KaaezWJAjMEAAEKAB0WIQQWnetsC8PEYBPSx58Rpy6gFHHXcgUCaQH4lgAKCRARpy6gFHHX ckPbEACjlYkF7MWG/wEbiOP6H5JvyALh/B9OFrKmPM1LM/UFQaXskpAsIWILwlcCFQjmfYb/OK5 f0auh39mZpVSR2cHXl+2KYaEIZ4xmlTl1UATnRKrCt5QtWCGuLtwG5i/O/EFvrPpei3vJFFiO1R EPF2Li4Kd2y5OA0QrCf3ssPORs9Hl5e/QUvvSwCL/m8mfJ2AN3DZ13SVezWk5O3jGLPAYXEwO6p tCkFlhEvpIDQ5m1FuzjcphPFgK+NZsTnr3pgxjnEF3morSktQxFraqnL+McdZTMJiWaawgXw1Vo QgTg3JAOlq6kgoh4NrdYAlg7mboV3GtNssgRbqENq5p5fDK4LIp0xkfz1Zda18Qqe4ucpr/Pf1z XmLT5hl3Ee8hkY2Iu/zXhK618YH3gerDRmED6d/XCL7TWkEq/UvTpXmNWOKlxjTZ2a2Y3kx9xqs gTFnUcpokMmLC/eFwEcQIT6b+GClp+ufnH/l94/28rSRZt4QNNkULCrOSNMKLX+t+eA//Chxyfg GD9dFaGpJ7aQAk9OHImV+xhowrQPJ3ZVhjkmou5X6XoVqt8KxP9s5MXJDFOoF7kquHTIUqIZZ0j 2FwjrM28Mg70hu4fkzW7MXfppWUYje8SFOGvWWDIj/I5yYNrugag4ZHP3U3mTnZXrUM4WHo62uO lr9QzzS3hxNQ5Dg== X-Developer-Key: i=bartosz.golaszewski@linaro.org; a=openpgp; fpr=169DEB6C0BC3C46013D2C79F11A72EA01471D772 From: Bartosz Golaszewski Provide an interface allowing consumers to check if a GPIO descriptor represents a GPIO that can potentially be shared by multiple consumers at the same time. This is exposed to allow subsystems that already work around the limitations of the current non-exclusive GPIO handling in some ways, to gradually convert to relying on the new shared GPIO feature of GPIOLIB. Extend the gpiolib-shared module to mark the GPIO shared proxy descriptors with a flag checked by the new interface. Signed-off-by: Bartosz Golaszewski Acked-by: Linus Walleij --- drivers/gpio/gpiolib-shared.c | 18 ++++++++++++++++++ drivers/gpio/gpiolib.c | 20 ++++++++++++++++++++ drivers/gpio/gpiolib.h | 1 + include/linux/gpio/consumer.h | 9 +++++++++ 4 files changed, 48 insertions(+) diff --git a/drivers/gpio/gpiolib-shared.c b/drivers/gpio/gpiolib-shared.c index 56b9b03cbb6dbcdf095a656fc36ff321770035da..c22eaf05eef23a7f5f111708c3d= b9412c4c30231 100644 --- a/drivers/gpio/gpiolib-shared.c +++ b/drivers/gpio/gpiolib-shared.c @@ -314,6 +314,24 @@ int gpio_device_setup_shared(struct gpio_device *gdev) =20 guard(mutex)(&gpio_shared_lock); =20 + list_for_each_entry(entry, &gpio_shared_list, list) { + list_for_each_entry(ref, &entry->refs, list) { + if (gdev->dev.parent =3D=3D &ref->adev.dev) { + /* + * This is a shared GPIO proxy. Mark its + * descriptor as such and return here. + */ + __set_bit(GPIOD_FLAG_SHARED_PROXY, + &gdev->descs[0].flags); + return 0; + } + } + } + + /* + * This is not a shared GPIO proxy but it still may be the device + * exposing shared pins. Find them and create the proxy devices. + */ list_for_each_entry(entry, &gpio_shared_list, list) { if (!device_match_fwnode(&gdev->dev, entry->fwnode)) continue; diff --git a/drivers/gpio/gpiolib.c b/drivers/gpio/gpiolib.c index c0c0e9370f150c340a7c79dc03c5afec64a440f4..fb4311d41161051dfd3c996b6e8= e9e8556b97cbc 100644 --- a/drivers/gpio/gpiolib.c +++ b/drivers/gpio/gpiolib.c @@ -3997,6 +3997,26 @@ int gpiod_set_consumer_name(struct gpio_desc *desc, = const char *name) } EXPORT_SYMBOL_GPL(gpiod_set_consumer_name); =20 +/** + * gpiod_is_shared() - check if this GPIO can be shared by multiple consum= ers + * @desc: GPIO to inspect + * + * Returns: + * True if this GPIO can be shared by multiple consumers at once. False if= it's + * a regular, exclusive GPIO. + * + * Note: + * This function returning true does not mean that this GPIO is currently = being + * shared. It means the GPIO core has registered the fact that the firmware + * configuration indicates that it can be shared by multiple consumers and= is + * in charge of arbitrating the access. + */ +bool gpiod_is_shared(const struct gpio_desc *desc) +{ + return test_bit(GPIOD_FLAG_SHARED_PROXY, &desc->flags); +} +EXPORT_SYMBOL_GPL(gpiod_is_shared); + /** * gpiod_to_irq() - return the IRQ corresponding to a GPIO * @desc: gpio whose IRQ will be returned (already requested) diff --git a/drivers/gpio/gpiolib.h b/drivers/gpio/gpiolib.h index c9de4bb10584206f4888c0f28468762a3680aae6..77f6f2936dc263a67b31a38799a= 841128a57603a 100644 --- a/drivers/gpio/gpiolib.h +++ b/drivers/gpio/gpiolib.h @@ -205,6 +205,7 @@ struct gpio_desc { #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 */ +#define GPIOD_FLAG_SHARED_PROXY 21 /* GPIO is a virtual proxy to a physic= ally shared pin. */ =20 /* Connection label */ struct gpio_desc_label __rcu *label; diff --git a/include/linux/gpio/consumer.h b/include/linux/gpio/consumer.h index 994d46874d560416175c9099e18180237839bd4c..cafeb7a40ad1c25aeb7deaf5984= 10d5f2f004a82 100644 --- a/include/linux/gpio/consumer.h +++ b/include/linux/gpio/consumer.h @@ -167,6 +167,8 @@ int gpiod_cansleep(const struct gpio_desc *desc); int gpiod_to_irq(const struct gpio_desc *desc); int gpiod_set_consumer_name(struct gpio_desc *desc, const char *name); =20 +bool gpiod_is_shared(const struct gpio_desc *desc); + /* Convert between the old gpio_ and new gpiod_ interfaces */ struct gpio_desc *gpio_to_desc(unsigned gpio); int desc_to_gpio(const struct gpio_desc *desc); @@ -522,6 +524,13 @@ static inline int gpiod_set_consumer_name(struct gpio_= desc *desc, return -EINVAL; } =20 +static inline bool gpiod_is_shared(const struct gpio_desc *desc) +{ + /* GPIO can never have been requested */ + WARN_ON(desc); + return false; +} + static inline struct gpio_desc *gpio_to_desc(unsigned gpio) { return NULL; --=20 2.48.1 From nobody Wed Apr 8 06:06:07 2026 Received: from mail-wr1-f53.google.com (mail-wr1-f53.google.com [209.85.221.53]) (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 8CBB5334C39 for ; Wed, 29 Oct 2025 11:21:11 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.221.53 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1761736874; cv=none; b=DePOt+R2JGBchE82am3ljvvT3R1KmcmkX9Yq1YbwFBPAVrvIA2q9cn7HI80ONoT9XssSucTVykhkJF1+ALItsroDx3rNf5BPP+6bXA81SNhpNSBsJm5rt1wXwHcZyVFBdK1MoBibSnyyAcdtECprPW9hY88v4VZNwCjQVTNy7Po= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1761736874; c=relaxed/simple; bh=qcX1d63axfEm3RBwV296f+6+sRglnyR7jSQ67K8y59Q=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=LUv48uPtcQAxDSRz+JQwAdfHudooYAF9A7srXXwRKmrIGRGLFNXFL8zkK3rCoZFK5yNbKtPpCyG9+fQynNJ0c2uzQnylt1pa8NSdW5BgKq9UZZhpVVjWFp+ydSO3HhgWSUj6GwYeMY4xkbMBd0L45ujPgFeVsLjKTxFxZ8k3bLU= 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=nRdhor2M; arc=none smtp.client-ip=209.85.221.53 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="nRdhor2M" Received: by mail-wr1-f53.google.com with SMTP id ffacd0b85a97d-4298a028de6so564386f8f.0 for ; Wed, 29 Oct 2025 04:21:11 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=bgdev-pl.20230601.gappssmtp.com; s=20230601; t=1761736869; x=1762341669; 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=nRdhor2MBH/H6treB7LnroPg7WBzKVkYr/IxZzYUz+IMjN2rKbNsL1CGsS8HAs70ll /gAegqiuKvsuFTOSQVtTrNMNLEib8/rZgxrYTzdX+XZd+12lkRG+xyCQhsxmRn37LdXY 4N/JDna8fWqFxrwAMveKDPGPbomB0aBQnwrlSEBCCYk9JW4IKDNUxLo/FyAnRB2vD63x Ir/0O8diIntZ423u9W/sPiL64y1p9dsC2J+X9zcu9mrPOe7X2siDjuQ2W3fUTtnVXhky lHwDifzLdptSXRx0NRo/FdZL3Qyh1C6pAMHORoXJdK/VwoBLAuxfJlUV2If1K8bdM6y+ j9tQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1761736869; x=1762341669; 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=EA1xcC9jO5WrouhmEPZmYPBcHdjAq+Ulgghc44OnCZY6lVr7H+g5VjXYaZsYICBov2 3xrkwp7lcxANn0wntAnf52jwRcAQB64DHnkdUywS92e0eFRDGzddms02fVHEWFjsIDlk bJgjTOWzLeJjx2Smad4k/YCZEGcnYG6je0IpHPwiwEMfmM1QW05bFZ0jXcd1PQKR+i3m xYgLVP1tW5miB+dBFbULzLC7Z8QnfN/2KMPweoLjCMgKNb/D0wdmJCGuRHwkjHU4aHPz Tr6WCfCbhSwMfVn7pJ6aliB13DRa0RCWsnL55uu+TMitzl1a9ULkkVeNdiDwXlp8058G HDYQ== X-Forwarded-Encrypted: i=1; AJvYcCVQRhbuj+cIaopX/+dc6ZotSrnn665cFHgN4MTWhVFn0rq61wSvH0K2k2ltV2a0OITqCXBqt8J+WHbY1xs=@vger.kernel.org X-Gm-Message-State: AOJu0Yy4p4Dz+gH6pO0SeYrKVST+oX8yeJBnMI3N9TQLzQetZWYTCwFX wGOhim/MikUr7j1L113kN+5WP2rmUtw1A1K+HS+1TDSvKjSq41Gue27jjLjdPCB3XiY= X-Gm-Gg: ASbGncvMpL+E1OTIqRTzucokGiZr9wEroSgIX6/b3uoga2v9W+0GitcZbbpJ2FlFKdf pKZIlZhTmSSQAKiY95Lw3pwoCf9GCSwrNcz5o2zCjzwXkZ4T6VB9oY1SFq4Jvjy1lfOK+1PgKUn 0PSFwrTDJ3hvtyDudTa6P8G0asx4P9IQbwh7x16olmZ3z22pDSHmBdHLEZUwJ0syhRWOODaTUeK hNV0zcmR7YvboB/98LaJPrxCfyzdYx9ieyD6s09c7X0ZhQ6OFIG5IRTEZiDuJQ/Sp7vEsLqK2EW yaZ9MHED4M4BEjJh/LwfLqDKwIvqkGkNV0mtQDFVst+Dq42atkLNRn5zKmcw7b23VMJP7cgmHAP PZPzmvIUK/flvgDnJoa4K1L4FN54MUH5fMjLYnEgomc6bQ6oRMbHtiWw6+V2ovTG83BrCFg== X-Google-Smtp-Source: AGHT+IEH6NN9LOg6FLsVrk8zgYabLR8BtA7vsvA+Q2uvBWc5oO4/7h3wh8g96410ssV5WtlYeIfHGQ== X-Received: by 2002:a05:6000:611:b0:426:dac0:8ee8 with SMTP id ffacd0b85a97d-429ae8edeedmr1897555f8f.10.1761736869351; Wed, 29 Oct 2025 04:21:09 -0700 (PDT) Received: from [127.0.1.1] ([2a01:cb1d:dc:7e00:69f2:5f2d:9ffc:a805]) by smtp.gmail.com with ESMTPSA id ffacd0b85a97d-429952df682sm25657486f8f.43.2025.10.29.04.21.07 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 29 Oct 2025 04:21:08 -0700 (PDT) From: Bartosz Golaszewski Date: Wed, 29 Oct 2025 12:20:43 +0100 Subject: [PATCH v3 07/10] 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: <20251029-gpio-shared-v3-7-71c568acf47c@linaro.org> References: <20251029-gpio-shared-v3-0-71c568acf47c@linaro.org> In-Reply-To: <20251029-gpio-shared-v3-0-71c568acf47c@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 , Alexey Klimov 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/ZANAwAKARGnLqAUcddyAcsmYgBpAfiXPD1vu8+WNIIVkn145b8DPfphfMN9ZAQUf MgZmrowGRSJAjMEAAEKAB0WIQQWnetsC8PEYBPSx58Rpy6gFHHXcgUCaQH4lwAKCRARpy6gFHHX cj+mEACXXeZt45Hp/bebUUP9FRIuCOwBltkwhyGWvMMx9PTg/virvsZSWrsbCDKwVHowTsugvBo ojQt+rBZx4fjXjEfaPniWVCRzIZBwM5eYEiyARKHMY5e8mRvLiwdRsDQFE1P/9IHy14ZVveXK9F dUGwyeOmdmwcXT65FhiDhn9+GIvNQ5BxaVKUqvfpeN6WThs0dx130XdGjauQ3kIhUdVyXmBpKnw L6jROZWZ3HD97GiGvKPDkUW+7DY3DMnl9Zt5F4ttq5ABoz1gUpfpo4VCb9E35lERHQkhJfIL9cI YyOMKGpPyeZ+MD3y9yb71MS4rRM+nKqK3oo/G4iYMZjaqjeDM2SgUI6QlOLfpDn5w6cabuHYD4O C2EiSXMl+dAzgifvoBldvNEZx1WtgR/sT3kTyxA01JX08FpSCP9pSbhJteuinINVnQALoyg10/f aho6Yi47ZdyDhExR8O7KyiLsjZkxPcDpP8ZymCQbRCn98lEVrYoVodLR9uBZE6ZB9yaijXt0m9f WkipfJMeZToVjn4CZRYcOkQ49nDv4C2+sgpy1+G6xu6Aee84B4Sb2fqa8WEKntpKBqBiLkQWT0o wLWY9t5n/E2aWM8d4UQ5uLNXLRj1PgYGAiX3df6Vv0NdL722eiMaLZj+DdSEmMK4s4zG2rQFsi6 IakNBGvF+FN3/9w== 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 Acked-by: Linus Walleij --- 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 Wed Apr 8 06:06:07 2026 Received: from mail-wr1-f41.google.com (mail-wr1-f41.google.com [209.85.221.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 51369336EEF for ; Wed, 29 Oct 2025 11:21:13 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.221.41 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1761736876; cv=none; b=BE5+o4hSIZj2fUIa3lRuvNP9ZPYIc6eUuAXtAFX+wR3aVVpmbEOeT4uNkjZjnbzUXrrcJg7SAyo1QIw4qtFZBK9YVINX8gYLK9RZWQteyi0BxzlDO27my85NNb9qD9LOdaJlP3rudBsYpOtsRMepOPro43l70FAKsKddPEd/KJs= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1761736876; c=relaxed/simple; bh=wXk+3crOirlJJ3BTqf/pNqQ/QmJIbx5e9hwDeEFKhJg=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=RlNFwNOTF6fs/wpAqujJ/9OTWAM2W5kiFiA9GihhGdTxRdtrZ8QsmbaAej2SPGJwoxr8T6ln4emsmZi4B+m4Oqc1SVM7TtOtSZu/DcPtUm+h8L4wSfYk+fQ5bbRG9F4mM+jR6wUHzyIBpWXePS9ViHqdiJiG/hbl8XDf6dPZslc= 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=1ffMZes1; arc=none smtp.client-ip=209.85.221.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="1ffMZes1" Received: by mail-wr1-f41.google.com with SMTP id ffacd0b85a97d-3ee15b5435bso5385179f8f.0 for ; Wed, 29 Oct 2025 04:21:13 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=bgdev-pl.20230601.gappssmtp.com; s=20230601; t=1761736872; x=1762341672; 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=ITkYH5qq6p2spjReXhvHRadCK4LlO30xMaO7HYP/79Y=; b=1ffMZes1mOU8fjR5o7wC+L01273unHdM0Mb+cyZsJ+3wUzEx+Ft3MEEL56PJxDOode /HuB0SR9xAgTzY5pJjKat0O+eT22V5ccFiXfhUqNLPCtE+dB2Gld/P102X3cMmGaTmVl y42s/dO1xeBhzqQ4PE3jS4rvuuVDMwwJy+R3esjwLF6maZ2pwXRfE2ZGBq9ET0kleItX 28zh84HnXqYfv2N3oVQCo3FnrsH0MxNGd3kygdPOV2ylBKRfqsfBlG7erlq09KaEJsBF TG9YkhnZaPiwC7FYeMI3F5Dq0TVwqdPmrITyK8wzWZGkOyXgX7rcsX1sERKwsCAC4PJs g0Lg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1761736872; x=1762341672; 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=ITkYH5qq6p2spjReXhvHRadCK4LlO30xMaO7HYP/79Y=; b=e6q6wkFracvayHP406SDHYxQ5X9/vrzh7T2elfbJZdIygYb8WD5hJeRq/+J/MbIx0a +djluHy6YTRd/giYFPYQRpOgERRhim/gB1BVwD/gyNHmfR19MPiiOVPpXzYapuQ7O3Kc /wsgsLz0eOxfKM83h3OB7NbxAJgOzc2RFpjH2QGWug60PnlBm7omqqcOGj8lpS5jUGlG ySLRwnpMTTt/Bv8AOj6kethiIvWqmS1fPRCD6nyGnFCsp7r22zflUJy72uG6vOfyvXco MQK91bUmzDkLPBFPtaGgT7tHLd8+LJQMtAkW+ZrIts73bIsWXwPyNPts2Tf1BonAcuVG a7uA== X-Forwarded-Encrypted: i=1; AJvYcCWqs6kLLfBd4NUZPc/cUd4eN6Lqxy3tqlC5ms/WPWIyXz1yTAp3+4g1azBmetvGqYOgrZIBAad0G5pnJvw=@vger.kernel.org X-Gm-Message-State: AOJu0YzVg+xu8t7dLjqEg49FJ2NgFbJIA0+v56f7EhL4BrkZF2/s2LCE pquI/o5vk7nN5eupxJ+U1/bomHJ1D+lRxU0V/JNxe791fAG3H9OoGshtEgXarz861hM= X-Gm-Gg: ASbGncuhvCf1EaQkKfOV27QxzGCUphh1wA/Gw+GJNtDXJrPOFBlkFwFEsrsKjq0/ZRD DUy7VV6lvi0amWoj0iLkwrgeAl89yhRpXs+pBYSmsfFMOXRyu1QHwV3qh7Ll5m5UedZUOSAUILk M1v1N8HZ01lUmIFczbmGK/m7Gyev+uUKfn26ewMzL82n9cmFQoc/PHxvJiBk8BTCDRbS0+CDv4z 8i83DvMdvWvqBr4XPKMXGIcHuuFW0Z+Y9OMGfbS+eydUBAQn0lCAc72mLBp9W4oSUIl/EPjnGK9 AgZsMF7NF8Dlc1sYse+yBVaG8lAKnxUFhYPak0+b8b7RqgLJwOY1sF4l5O9wtEsdPgm6r4muNRr 6GCRzcmZf8j8AYX/tHVH7YXYIhBw+gJd9I2xSr/1l3YU8ocYr+gLF/zxPlwDz9p0VOrONbswlne cevgXe X-Google-Smtp-Source: AGHT+IENSqWLO/JMNJLWEfyUHP3Mjq4W26Iv0qEKH3r8OB2YkTy+FUkLuZiv4z7uvfVY/XuiHdrcmg== X-Received: by 2002:a05:6000:4021:b0:427:60d:c505 with SMTP id ffacd0b85a97d-429aef78e49mr2088157f8f.15.1761736871599; Wed, 29 Oct 2025 04:21:11 -0700 (PDT) Received: from [127.0.1.1] ([2a01:cb1d:dc:7e00:69f2:5f2d:9ffc:a805]) by smtp.gmail.com with ESMTPSA id ffacd0b85a97d-429952df682sm25657486f8f.43.2025.10.29.04.21.09 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 29 Oct 2025 04:21:10 -0700 (PDT) From: Bartosz Golaszewski Date: Wed, 29 Oct 2025 12:20:44 +0100 Subject: [PATCH v3 08/10] 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: <20251029-gpio-shared-v3-8-71c568acf47c@linaro.org> References: <20251029-gpio-shared-v3-0-71c568acf47c@linaro.org> In-Reply-To: <20251029-gpio-shared-v3-0-71c568acf47c@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 , Alexey Klimov 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=1052; i=bartosz.golaszewski@linaro.org; h=from:subject:message-id; bh=iK0ZywBEmfSVw6xPFQX6Oke9nUVZV1pPcQC7Xb1WLtQ=; b=owEBbQKS/ZANAwAKARGnLqAUcddyAcsmYgBpAfiXKnnAKknhcraojtkxn3HXQvIqfHbyL+bzN EXTvAFatICJAjMEAAEKAB0WIQQWnetsC8PEYBPSx58Rpy6gFHHXcgUCaQH4lwAKCRARpy6gFHHX csiEEAC4y0Ps9nRfERWW+TIRHLw8qrds7gW3K+kxaWsNsBT38vOQRrALl8SNYm7GZ94LluEso9n SSL5AT5boIXTnkKpKhUsNmRhvoaLjsuUtlE1AA/iJvZ6//AC34+pn6a3lOlQZ/s8M5rvRUvNzCc /AUSqSkyyElorHQnZsVm23TiMb/h4chxqFQ1mzI1M2CaFDVugOHv3SZyOV5Yus7GI5c0uvt97Cy sWYE8PC4I3Io8+souZC+TdOkjA+DJuTjKURoijR4yUrYmiWAVyrz+0C9W9B7orM6U2G+o9DMJwi KQplI+8j/Hvq/9j7BdTbgEJmjhj6o3haaszRDVGGKcVhKQZT/hMfO5WOtpxcXUnGh0a9PXeCNvT ybgTvSQChRrkrZ/suBk7OAtLas9JNP/AV/ADIwkvT1Qg5YcFUQywjrBccQJaA9XrZ7dUQar+4NX plHV0zHPlCYaVSBIjTfUFKER/m41CuhFiKhU1CaIife+NIwemkfvoJNWoYcUDrMwT7Qx4H47jDL mUHV3+jE1kwsAHpCEE5EvjKnsgl43pw/R1IxgYaUrcDQxeyO3Bqy+8l0FvyCD9yINbpQNKIwPcc JtOZh2FqyA8AZW2dDandfZl9eVndB4tdKfVWQghb1jzvvn2MlVP5t04RU101IMPqdKH51lxIBFj yj8vFSO/EhCgneg== 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. Reviewed-and-tested-by: Alexey Klimov # RB3 Acked-by: Mark Brown Signed-off-by: Bartosz Golaszewski Acked-by: Linus Walleij --- 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 e249de7f91d91f8c7f1e7020086cc65c71e64c5e..d7aca6567c2de1ec36e9f36aa82= 463bdbf3be27e 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 Wed Apr 8 06:06:07 2026 Received: from mail-wr1-f44.google.com (mail-wr1-f44.google.com [209.85.221.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 84B85337B92 for ; Wed, 29 Oct 2025 11:21:15 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.221.44 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1761736878; cv=none; b=ku6dCk3iYFGq6U1CAlcB3XFljwJ/DGgwr+APXkZtOyUSGgCZ6LYwcSk+PsVPsGpv9tOwy4z/uYqeeAQi6xOnR2kRpJgd5YzTf6045JhfSZv2rRZ5RQZxuWv/45gXdT7+LyzHOsuM2HPabdMaphjrJfOmjtw9ThSuyr6BiGc2lNs= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1761736878; c=relaxed/simple; bh=t49A/kBppSVTxxxXVfsc6pd4jOUk3IVyTl41R7bfQmA=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=HJkpSiPXfEpxz08l7YLQZz95i6MVhj+2r0ucD5/hSH5F945vah8+iMnuH8B3HNRFgYYuca7ul9r5JDZgDiUjh4Hj8HAQUbT5zCeAEGLkTTA42LeSQ/Ap8LHR7LGYsgrDaF7JRmN77yM0axGOg/zwHAKJtRcU/TWJxoHPOPEPNCc= 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=P46194gR; arc=none smtp.client-ip=209.85.221.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="P46194gR" Received: by mail-wr1-f44.google.com with SMTP id ffacd0b85a97d-3ee130237a8so4695781f8f.0 for ; Wed, 29 Oct 2025 04:21:15 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=bgdev-pl.20230601.gappssmtp.com; s=20230601; t=1761736873; x=1762341673; 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=CSw2EdxjOi8kYZ3PupDeUSTW/56qTSGlR/hARhYoX30=; b=P46194gRLMInXXN3IPuYeRafbyKTx38VXF0ZU2+P3qSaw2rzKfeIBc4wRIRSNHqS/K IM4a0d7y9YIUH8aLCURa0586cDUYG5EInyesYMyp0csEaxmY0emJO8LhdYxxUs4dBNt+ oOjv5Wf51zh4JDGeSVcQvCApDIh5vBhUYWTOjL/kVjMENF/4P4FFe1NfkFRi9Gsonoqg YkZC/aBbRwKxOuyC76ZwHhgqMHcqKl7JswSgergfeBnCjKgpFXsF16VbDQxR6q6dY9IU /8bUMIj+hP8MQQ6P0K6c6MTkZ55QFTm1ftxX11FjfXtWtPyTYcP+Q1XII0NKkl6rzbiE UFsQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1761736873; x=1762341673; 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=CSw2EdxjOi8kYZ3PupDeUSTW/56qTSGlR/hARhYoX30=; b=mfRMZ7Z2pTlW8wpyUZd/g1bOXYChTWj7pCqkw6lxTO0LM0P4Cc2CKud1qK4SmpE0X6 1L8FG+JF/vgunBhLYbQWNOYIoISSwVZJwWiXY8St3N4Iodj34K2hXa6dwssnz9JiFuoM YVIiiwpcOMLf9DOrakx6zUwOR/bOzUodHySs4xGHyyOLf/r6r3J/FuZbxqB4oQNjh3cP UdxtXYdkcajqtbzS0T+Y25qiKbRHNnmUszQreeNKjoyH2lDGVNJ0WtGMWEu49vg+OMu0 RngO9JLw4z/UmRPL59nFS3Z4edidptda8ed20OXksiDR9aON5Jju6PNgRbAI3Hha2/qT i5Zw== X-Forwarded-Encrypted: i=1; AJvYcCV/ofclStNKGMb7pv3sXhxIdSLCTdvH45w56mYd98dLbVnHWWYlsFTR/NQmwm4fBWNSckDtA39EaHg106g=@vger.kernel.org X-Gm-Message-State: AOJu0YxY3GbACXELY6/jLLtI/fWRKhxhOT1yg3UiiWj+HgQdqJ4Togrd YOYV86w3qbXkhIbzPJpkL+jXgd+NUWw4IsfMFeVorm8kisofjuYAf+p5DUHyYGrWrio= X-Gm-Gg: ASbGncvkdrHbslYURlMqzxNlebSvYVsZN+0Eiw5u3a1gS83TU5c16zxhadAp/ddTGhT Xbjv3c98WBWZ77mEu8Y3e4OJ7b+0JTanC6so+jrkzdBXKE79qBwgnyXLO6aBSb/UZuQrK6dpUfg 6tn/bzA4BiNX/YpbLm5GDK+QiQXZ+rYr1IZldgieTKv/EfKBATqd5RecFNaUXTiVyw8fTDPhpgO 9hK6piePzREkEPd1kgzecUzt6V6jJptlxki9gubi/X2Wu9uR9WkZRNjpIhzQNOnMM054MU50wja bVI2ezbMgRshZjiRZ15Vhoz5gMHiQ2jJstbYGMgTn6xmhpAV1ccawd5G51TA9meA9xJUJPezbeM wnnl0PqtaHlRU9hYVwlgi2R7o3WA1QeXxLgOf5wxdsLPQ3f92EG92dwgy9WNOZyYwgGwDefp0tS zelxWZ X-Google-Smtp-Source: AGHT+IHFL3/SEypSJwx0z/KiduAwAaTPznbT5JJfFEzpWMAJnW6K+9SO/RgtFfJleuosrj/o5yax2Q== X-Received: by 2002:a05:6000:2089:b0:428:4354:aa43 with SMTP id ffacd0b85a97d-429aef83083mr1953832f8f.18.1761736873302; Wed, 29 Oct 2025 04:21:13 -0700 (PDT) Received: from [127.0.1.1] ([2a01:cb1d:dc:7e00:69f2:5f2d:9ffc:a805]) by smtp.gmail.com with ESMTPSA id ffacd0b85a97d-429952df682sm25657486f8f.43.2025.10.29.04.21.11 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 29 Oct 2025 04:21:12 -0700 (PDT) From: Bartosz Golaszewski Date: Wed, 29 Oct 2025 12:20:45 +0100 Subject: [PATCH v3 09/10] 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: <20251029-gpio-shared-v3-9-71c568acf47c@linaro.org> References: <20251029-gpio-shared-v3-0-71c568acf47c@linaro.org> In-Reply-To: <20251029-gpio-shared-v3-0-71c568acf47c@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 , Alexey Klimov 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=1285; i=bartosz.golaszewski@linaro.org; h=from:subject:message-id; bh=vbLbGIRrVxCCk3wt/NECqvmCZHfWshBV2zBTPFShXA8=; b=owEBbQKS/ZANAwAKARGnLqAUcddyAcsmYgBpAfiXMGr304xGBu7tq+dWAfIS6q2tDWWQKveWm r22V+7NbSWJAjMEAAEKAB0WIQQWnetsC8PEYBPSx58Rpy6gFHHXcgUCaQH4lwAKCRARpy6gFHHX cmvWD/9A2sOwmknVVLQVKABwBt8qycLb4JNObvNJ4aRgS6PD/ENhwvX/HEy9aPpX/OPWJLDaWBi v1LS7Jo2LbgVh3gQ/k9j9zogkLL+fZLSYgjIzsYzCsc+fv0Pf+Pd2hM1F21g+nFzqpIaeE2bjTf lKKtWoGDhh3cOB5Ynw5OZ0lXQtdOPkY0ynJp4d4SugeLwZ2sVlboPaFVVInEjP9jbDX+qaQGUtW ZXz1wxfDEey087MB54ZEKKSJE8EkOckNaSrJwGteoDmImCmdnQbvG+gOS7cr4LSc+wU4BPwqY2G 7kAq7gg//lCBUGn9fJu8z3PFHmp10lO8GovA9M9UTOaIDq6yAhJT/QShNTDlIYqajICuLe/9r6N 1XylMntalgyk/QeuFFbM2nShQKrR6nj5f78oWbDBXtQZU/Nfd+n9KZ75/OmmS71h4vNvccn+u/f QMwB/wSuHbYZY8m+hnL7gbiF7TMPccpZiIh3duEFfFrnXz51Ux5ROW9PPZ8CREQh825sXocYvfy evWCuhwluI3Jshr1EFB1/QPtGa4E3iFjfuaxJFv4DQMcWxflUT02mQesgQtabdaFBa9PVnDpPGA mx3paf/ZPiy+CzHgnMMTLxs/1PLkFKjEMV827AEeyzgzv1kZnsIWJLxttu7Sae9eYoBW+Qdje/Z ZcfHMA13BxzE1bQ== 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. Acked-by: Mark Brown Signed-off-by: Bartosz Golaszewski Acked-by: Linus Walleij --- 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 96dd66c4b88dea34f1f24bed4d5ab66d3e2249ae..c3046e260cb958296a41b78b545= f1ac7f377a968 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 From nobody Wed Apr 8 06:06:07 2026 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 71DA233711A for ; Wed, 29 Oct 2025 11:21:17 +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=1761736880; cv=none; b=RbkDvFT8+lwEAiFCOmO0OPkx+AyTXCOZYzZvkacEyKfMvRoObjBS+UamMM+RpdAfPiNqCcYpu+ixo2b2zbQg7+9zUER6J4JpJxyXKwXKtCSvJ53tfzXudOvE7S3wrvGKkDuYs0ImFFhCPdmKD2hJ0PnaUpxcddkT2I8wciwWKUY= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1761736880; c=relaxed/simple; bh=+ydNsxmsAlBQnhT7Rao8bdkeqweoItUHWkkNDmPd0sQ=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=XhHlkE57uYHOJVIN1urOL+zy0UKBpE/0xjwgP6kIvcUSUukoWPMuGW5splnWnVr8CtNeFCnpT/hujyP/S6pAU+gbHHjgsQANKa7qb5rTsVUcURRu2eorjXaZy8qfNkCkA7fl6+7WhjXMdHpAehtFZQET/Wm8qD2uUlUTsiTZMO0= 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=dDOzwtaa; 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="dDOzwtaa" Received: by mail-wm1-f52.google.com with SMTP id 5b1f17b1804b1-47112edf9f7so46680895e9.0 for ; Wed, 29 Oct 2025 04:21:17 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=bgdev-pl.20230601.gappssmtp.com; s=20230601; t=1761736875; x=1762341675; 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=B2rTEU/R4flNUm5DKfIw19dyA8fnd0V3L0Lxu0SXKBI=; b=dDOzwtaa9OQ7o9Ckl2Jvh/FjC6JHGpP1WSVC0EUyh41S2UOSLX3hyVrSl6cqKqUErD TGFxFr0Z9lL/JMaD5NFSIZJakAp32vHn7uvEgrvuxfVi2f38ImhiyI9tfBeGH4EZ2QMV q1RH99Ek98k7q+khIUd7Up9x+OT1XV/EpjOQgCVcyXxqR1GcvwPz7Ih80PMhNrl4Xs4A zuWLHV3Pwx4DVX6YdU0Kga0jTGqqTXVFpRnAW3nuzX77tlatd51xAIXS0wBdi99nskO0 uFIM56CnTiSkCgda/3PcFYEHJw5T1uHsJdD6myNDswec7Sh7vE+oJ0b23sGdzWxC36V5 yOFw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1761736875; x=1762341675; 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=B2rTEU/R4flNUm5DKfIw19dyA8fnd0V3L0Lxu0SXKBI=; b=cV2uHv1lMjTlDbC4UFEJSLAyHnv2bFNhe6PJWde9r+lVHy93X1CMrPTHYiaxf+tFP6 eYCyne7Rs1ZE5AhqvUaz7EETR7aibaEwcNBEqW/vwYXtHVXfpz7MACDAjF7w4Wy6OQiO xs4GYsgAyD2m5Ub0veDaRq30gPSnToBUjGhBNt9EVldPZAz1td0YSfGX2fF5DFiLc8YX Sfy26lDg03NOE68Bpnk7nmcy10MEROH7wWOtKfcCem55zOvqHLoDUPIcV5N5Duyr4gDQ 3S/h7fU7aZ8PnwoXjw9Ag//M7Rl1GTV+DCB/fQrNDHQ7iSb3JAY058CE6HwTZMuP5zyx kJUg== X-Forwarded-Encrypted: i=1; AJvYcCU00gx37S8v9Op2CtBT/+hJDFHnYlZkHO593eS5szRmnwXBKNYchjUOwInLK17twuiV0LcDqIbDLYK/h3I=@vger.kernel.org X-Gm-Message-State: AOJu0YzfwAGo7uttJWerJppl/rFriFTieet7eo25gG5Xl/g45AfuMO0A iOSxj4+ubgg8fIkXGNNMwy8bw9hNG11wn6JaP6IeXXijHbz3tgMgkEUJa5M/GI2rQZ4= X-Gm-Gg: ASbGncuLTMEWzDtbwJcop9awVIWVEhT/PTKsO92iv7UffBbNG2iSdkfLyATl31DUFQB OEGd6K8ePjOqRza3qwmAogvFveqJasyq8T+eDWrnm0nVRn8EGg1Len/rJxfNGSUa9yZImLO5zD/ Dcb2RetQgIXCPcMeuIMgp8FUhBNiIzksrrAqPr6ylajkjHB5fnPGBooMfACUQejI6V/8qdzv+I9 NFyQO4I4b0yGBSrbTkyMIbeApeXwEX2I+ZWi62wY6Oc0Kk8r5dN7BYFlyr9Ggxuz9swnJJqGxQ0 JKrj7fDBCwvjJ97for+FzHhECDePf/nJHfwsHOpsDkg14R9Y7lzABGvNOEac0lrqExqL06sKi6r SuW4lOE4PEo+LkE+vXdehsQD7RWjIlnByJNJklHAx3WIFdt512schN++XpllmygGjy1r4Iw== X-Google-Smtp-Source: AGHT+IGR7PwU0mQOpYzSCMCZbMwDSmhLvLVnDgvEOcrKX+beh3H3tKQBd4cE2sGECLQ4LCyzu99rrQ== X-Received: by 2002:a05:600c:c48e:b0:477:942:7515 with SMTP id 5b1f17b1804b1-4771e17e177mr21559155e9.11.1761736875026; Wed, 29 Oct 2025 04:21:15 -0700 (PDT) Received: from [127.0.1.1] ([2a01:cb1d:dc:7e00:69f2:5f2d:9ffc:a805]) by smtp.gmail.com with ESMTPSA id ffacd0b85a97d-429952df682sm25657486f8f.43.2025.10.29.04.21.13 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 29 Oct 2025 04:21:14 -0700 (PDT) From: Bartosz Golaszewski Date: Wed, 29 Oct 2025 12:20:46 +0100 Subject: [PATCH v3 10/10] regulator: make the subsystem aware of shared GPIOs 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: <20251029-gpio-shared-v3-10-71c568acf47c@linaro.org> References: <20251029-gpio-shared-v3-0-71c568acf47c@linaro.org> In-Reply-To: <20251029-gpio-shared-v3-0-71c568acf47c@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 , Alexey Klimov 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=1401; i=bartosz.golaszewski@linaro.org; h=from:subject:message-id; bh=GIqAeLMClqYJzQksRPUzaJ9e76p5dkwgt728MWTS1+0=; b=owEBbQKS/ZANAwAKARGnLqAUcddyAcsmYgBpAfiXYH7uSZSvv2U/L5oE1AwbmsCdQLfg+BT6I BexNof4UFKJAjMEAAEKAB0WIQQWnetsC8PEYBPSx58Rpy6gFHHXcgUCaQH4lwAKCRARpy6gFHHX cjuVD/9pKMy9xOMmFOqySa84qtPZZ//MaWg8zuKJKEL2j3t/Hf1aiGZpWMx1/YNjCFZIAGQ3H0A NmjnygexP/IQFMGnRRSzA3mCgF/IU11qJSprjKr4evOZYIqoMxfFlWR6eDpuSncPQmqpCSV9MDl YZ35OCglMwmVOaFaPRnjzfhvhbGZkpo03RrPkeI7EQ+v4h4S2bpY2UveAKe71Br5o57eAmvik8v rwnRwpIvS1cmm/zK02sGg0go1c/tbdKbFrwoGdJ1OZhEtTxv+iiB2PXpc22/MJlDUi0mQBhS07m b8LPIoT6scWDQHlLr1K5qWSPfJt7u5OhjUfhXNa8Q/GdP6ViFr8EzemKdsBjUeJxwkOVS0zWc77 V4kkjWa2olMwV/ZgOY313FoUVqBxBu2lCJuEE5C3F34WDSVzP80gsG9VlL8yznE6JhH6MaGf5ZA 0zh3q323KhY+vaQ2Nb6MbS1C7sKA09nuBUZEOQ7HoD2oTY9Pp6krNOpSDNkJnT3jdyQrIfTvRlL fwpPx0GQfTYfxGonj6ayd0vZO/elG2eQSjCgUUcsdVvYgrasgibmrH6S7kxSo8/teNU4ptvP8H0 fjA+DVAvFqG6lY5ipB1BVRVcoaywy+RgkCu5Kqk4zWOBT7yMzLZzxgNtsDabMykXPK8ciXibwvJ zSkCr/gfsw52I2Q== X-Developer-Key: i=bartosz.golaszewski@linaro.org; a=openpgp; fpr=169DEB6C0BC3C46013D2C79F11A72EA01471D772 From: Bartosz Golaszewski GPIOLIB is now aware of shared GPIOs and - for platforms where access to such pins is managed internally - we don't need to keep track of the enable count. Once all users in the kernel switch to using the new mechanism, we'll be able to drop the internal counting of users from the regulator code. Acked-by: Mark Brown Signed-off-by: Bartosz Golaszewski Acked-by: Linus Walleij --- drivers/regulator/core.c | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/drivers/regulator/core.c b/drivers/regulator/core.c index 84bc38911dba308539a25dd3af30a5c24802b890..e13cf5e120466cebc4d3f8400b8= 9be07d3303338 100644 --- a/drivers/regulator/core.c +++ b/drivers/regulator/core.c @@ -2737,6 +2737,13 @@ static int regulator_ena_gpio_request(struct regulat= or_dev *rdev, =20 mutex_lock(®ulator_list_mutex); =20 + if (gpiod_is_shared(gpiod)) + /* + * The sharing of this GPIO pin is managed internally by + * GPIOLIB. We don't need to keep track of its enable count. + */ + goto skip_compare; + list_for_each_entry(pin, ®ulator_ena_gpio_list, list) { if (gpiod_is_equal(pin->gpiod, gpiod)) { rdev_dbg(rdev, "GPIO is already used\n"); @@ -2749,6 +2756,7 @@ static int regulator_ena_gpio_request(struct regulato= r_dev *rdev, return -ENOMEM; } =20 +skip_compare: pin =3D new_pin; new_pin =3D NULL; =20 --=20 2.48.1