From nobody Wed Dec 17 12:14:28 2025 Received: from mail-wm1-f46.google.com (mail-wm1-f46.google.com [209.85.128.46]) (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 50C0F242D86 for ; Wed, 12 Nov 2025 13:55:42 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.128.46 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1762955745; cv=none; b=tvA5KXg9svFz6b7y1mLHO1VOD+MSO8AQZuDmtY57ffTdO4KGehz++72gK5Ypry9LGntnNoZp8Hvta8Pdw+nmkklYVgYSsURojMraW97p/gmBG3X2Iin/a+LjLVFf09ZMWg3T4okT0sW+b/38Jjsx39za/G4DCF7Rdmm6ITyqE/c= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1762955745; c=relaxed/simple; bh=HgxG4lGvDqlW7/AsnynclQLHI/pvxu2uFzPRwebWT70=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=O1x4pabk/Bpl8UJX54GeBKAws8s0CUNqapSjsn4OvR2ZIofz/Anfbl1iqUqcX9sIEmT+46anp23gOtKGHsaxglfEF7dy47wkOQZYzP8M7/18sJnxc6bysBsVKTcc2AXNPRgbMaq+g9D9Hbl3yIioDoKjpgm5QhGsdKLaRsgiPaM= 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=hX6YPTuX; arc=none smtp.client-ip=209.85.128.46 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="hX6YPTuX" Received: by mail-wm1-f46.google.com with SMTP id 5b1f17b1804b1-4711810948aso5886935e9.2 for ; Wed, 12 Nov 2025 05:55:42 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=bgdev-pl.20230601.gappssmtp.com; s=20230601; t=1762955741; x=1763560541; 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=e/PxI7IDG8K3Rp8aKLf0DGe+okm2zdYYk5VKmu5ka3A=; b=hX6YPTuXwEpmt+pSLK442iSQ+ke5QDBSPAYKAUIZUZu2QItcGw7GyN6pr9+IlgDDxt 52ba7Sk30ByFd8/NAYSobaWI5A6Iey5bpZ+x0zY9MCAC8vJFDUMsyDPsozoAcMOPXk57 4ZJ4M2Atf8uchy7FmmPKw1f31dsgXZwEu76hFkKeZAEMOFjeASB+zg4Aa5ov2jA78fMY A+GFnz3WlD/imVTFwFJWRyP5NAmgsavw6y43KSuA6l5e2gdzxxsZGDRDwgsXt41QrM8+ TZtByVp8HCbj2ArkKXS+gsCZCz+kl9nEvYMQzTPiD48P5KWFTsRwF/uhHqwqGnXxHljX JNFg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1762955741; x=1763560541; h=cc:to:in-reply-to:references:message-id:content-transfer-encoding :mime-version:subject:date:from:x-gm-gg:x-gm-message-state:from:to :cc:subject:date:message-id:reply-to; bh=e/PxI7IDG8K3Rp8aKLf0DGe+okm2zdYYk5VKmu5ka3A=; b=rfzyZ+9WELVuidEN7xZCtNUUY18YzngJsV43jzH8TsvNYXYxgdsG3pT/k52lhZuBzI ErTQP6vRNdWyVA34cwh8f481DcWkm3JYUebPIKJEVa6CA7ZM86FXSdhTPVjIQ7OjLmZZ gD86BjIi7qHh10Stj9eoMbLVXS5ULHcyseAUEPNkEOI+FvHhakdZRonxpbxhNOCNZntR sSmfdvamrsZyUnOq8Hcz/q9R4QGd7TkNx1lScD7XIbkZFgieGP8hRFqYE8BySOAxtDV5 XkqnlPOCHdHdqOkySWTMSVmA5vqwH4hNuIuZ/pqeXfVZxKXvjq5RbDjdRPCMXVZE6Ieg rgvQ== X-Forwarded-Encrypted: i=1; AJvYcCUvBv/mBHAfezEkXtfeBEPCixJ1qquRrl9I1f4afNTDus1GFilWk157ylTzqg3Gkww+ebAPVloeLhpwJsE=@vger.kernel.org X-Gm-Message-State: AOJu0YzZmijtzC5NLFHao8NtLRiYk6Sn0XgGpy2yyT3WKH/MXOvBuxiI WA1qcfKMA/5HjPTIgPY1MWKI5C91GxxA+q5aPrM8EFWrSEdTwrzkk0zA7qFDWmcfe7M= X-Gm-Gg: ASbGncvlfU3tDyYsgB1ud4rSB5M1lvz161vpA/3Pk/TlEhHDis/GEIb15aeO0nIXgyZ ewvXr8YwI5HtMPB4XwQ0rjsoN1sRh80q9HtVRhSfTAG0S5JqE/eGz/xSfW388GnNp4RAlzmZtPF Vt0Yop4YtsJhAGpIO0ayEqixBAEzCy2FpEcJ3/6LH+ayIF+wpJnsIBG8NFYu5c7TZsPJ7LPYy9m wTU+BZCTrc279hwPRnznEXh4XJZykE1k2QbRxZuOmfFaP/o9HAik/VUHaT32gKk9E5qV+Q0KR91 w+//0Xw/i2S6euUEjIVeu55/MhxHU2+PL6/CTgKMYKMEIkDptk31v53qhhaqXZv58ZSIzk51r8o VwWToxkgF3ss8fEWFjiXiFk+K59CJje4P7P9vGzLjxvuZqSUn95oEqKrqnuM4e0Ofq/s= X-Google-Smtp-Source: AGHT+IEkRu/791wAeVxaQxp1qqgS3vo3K65X5o46qGVaUvWLYsNeU5tcRsDz23Tdw5hX7vdTv1ja0A== X-Received: by 2002:a05:600c:560a:b0:477:8b2e:aa7d with SMTP id 5b1f17b1804b1-4778b2eabcfmr2794085e9.30.1762955740481; Wed, 12 Nov 2025 05:55:40 -0800 (PST) Received: from [127.0.1.1] ([2a01:cb1d:dc:7e00:2a6:e453:42d3:11]) by smtp.gmail.com with ESMTPSA id 5b1f17b1804b1-47787e2b835sm37711685e9.2.2025.11.12.05.55.38 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 12 Nov 2025 05:55:38 -0800 (PST) From: Bartosz Golaszewski Date: Wed, 12 Nov 2025 14:55:30 +0100 Subject: [PATCH v4 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: <20251112-gpio-shared-v4-1-b51f97b1abd8@linaro.org> References: <20251112-gpio-shared-v4-0-b51f97b1abd8@linaro.org> In-Reply-To: <20251112-gpio-shared-v4-0-b51f97b1abd8@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 , Bjorn Andersson , Konrad Dybcio 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=2522; i=bartosz.golaszewski@linaro.org; h=from:subject:message-id; bh=NlwU7Iav+zXTXT3/fww0HPRb4T18AYGPoXkxkIX1TvQ=; b=owEBbQKS/ZANAwAKAQWdLsv/NoTDAcsmYgBpFJHULZbr/rzo1SGp+CZMmaM8LAFTvG2Phhgh/ gXknU2GN96JAjMEAAEKAB0WIQSR5RMt5bVGHXuiZfwFnS7L/zaEwwUCaRSR1AAKCRAFnS7L/zaE w4llEACvO76e1Z+11Wt9stMT8nt5Xd7poTboTiqIpNa7/zy1Z0GEsEDf94lSJ/UH8LczyCwHVXD j8xWbDY0qNWkjv0JgLTClvjrOl85dQHdVvHxKeKP0ZLuiuscFQGpvZUTp8AsNWFQPEtlN3LLaiz ooYYDo77Ff8G5DbGYaDA7hpycv3vbEsD1pA1VlWzMOs03EN2jVs7ZP9LAwvujkEYtop2HO1fwXT +r4YkLwaHsGmCMgSxtwvslG3+H/fN6H/T0FuSIQTXrclWt39Gsxg2FxL1HxLPbu2zMWS0EL4pKD W5I7vww1qStuhvyBR1sf3bkf4Sm9pcvlpKLCJnmUxAAyzJOw+aoDvWajtnQua2DlqUy73VDuoJj UaitJ+CSofxBn+OMKBk3IsE20o5z7CsAdoa0S1wUK2dg8XxJqiryTzOT6zWJRYdCpauKD21/+E8 f7SiuJZ7QyQkcDQBbpdQii6lD94oQFd8FMFNKaogV+/LBvE2FWUa4UbCfmYFcV/b+1xybajq6rV ZouVOU1i/FivCvcZfZtQ1akl9qZIMfaxB0czgHNdT3pajsiscNnqs929HQ5mORLG7SuNy3p586V hehheWhg7ZTbzJ/8FWiyOYgnKVprVvop3kDt5pBZIROAR7MXNCHZ93enl7OuPvUYhNKzAK9v5CO idZYiRwCMJSHIIw== 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. Acked-by: Linus Walleij Signed-off-by: Bartosz Golaszewski Reviewed-by: Kees Cook --- 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.51.0 From nobody Wed Dec 17 12:14:28 2025 Received: from mail-wm1-f43.google.com (mail-wm1-f43.google.com [209.85.128.43]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id DFC9924A06D for ; Wed, 12 Nov 2025 13:55:43 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.128.43 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1762955746; cv=none; b=h4gWF3FdqwHR13sn0AtR5a7Eny8nbVG7GNAMexLZDpM+nQWOLtPGcBGBh5No8hCt7NiHgvTOFoB8xQclA3m2O/wiGJCZnzy88za0uJBAzwpAG6tHefXyNWCmzT2jp8FaRtQStWE0N1cvCh7GEKPyCBshzeX2+h82RB8jX1ZXDr0= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1762955746; c=relaxed/simple; bh=KN033bDXd68p0ygzAwO9lMJaY9FplVJ3RsK58yXEA24=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=i0bsbz0N3iiicsKvfAkdea50rSZpkKEy5GoxC6t17e8CDs2sOana9SFaaITiB+fSewMyAlMnipurfNs3JpXq6IewRenonf81oJSO+yWnDq7pngkSSgBtt3PO4DBZVz2EZwz8auXO9iTy03haknhGm8dFmZ6FlAX2carIgfJlNRI= 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=WE6btBxV; arc=none smtp.client-ip=209.85.128.43 Authentication-Results: smtp.subspace.kernel.org; dmarc=none (p=none dis=none) header.from=bgdev.pl Authentication-Results: smtp.subspace.kernel.org; spf=none smtp.mailfrom=bgdev.pl Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=bgdev-pl.20230601.gappssmtp.com header.i=@bgdev-pl.20230601.gappssmtp.com header.b="WE6btBxV" Received: by mail-wm1-f43.google.com with SMTP id 5b1f17b1804b1-477632cc932so3974065e9.3 for ; Wed, 12 Nov 2025 05:55:43 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=bgdev-pl.20230601.gappssmtp.com; s=20230601; t=1762955742; x=1763560542; 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=2hgFs5jtdGYJBZ1LEdVbgHUHnMs4CKKuQJyrqRFEph4=; b=WE6btBxVDTXx8n/dyWjbAKye7yMioyNQIy2em+DowK6RvO/+CgSaF3xiOwEpadP6J5 Yu8dO/6INKWUvsFR0NkfG3bXVYJKlP65eX8EbUhw838I+0Y5SpEzJVqlNOJFsoQ90+8K g6H5v0ru/aiWVUtw53AV2066R+F8u5cLQSvrnFErvWu1tZye2n2zzZkCg09nwtaLa1l5 jXdMSzePO+XkhnI6u89UMZC52jNS8BGZqqerC/jyGIO5VLzWf4NhHu+Xyj6iBw1ZA5fE 2JClMCr1oPzngthmuIaW6WJjGBkx3dYFE11YvCjpQoRLvXin6W4bycFfslfmQGv0/REk igig== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1762955742; x=1763560542; h=cc:to:in-reply-to:references:message-id:content-transfer-encoding :mime-version:subject:date:from:x-gm-gg:x-gm-message-state:from:to :cc:subject:date:message-id:reply-to; bh=2hgFs5jtdGYJBZ1LEdVbgHUHnMs4CKKuQJyrqRFEph4=; b=S4tmGjeF0uk3RNxcpiOZQv+EFpo4c7yeSOckAXTDXpLa9OwJFkmynEQWfdAC4fbOjk nejR2YHTuPn9iECwgjRuUXos4gx3n/AbsYkebojlCu2duyUyHp+aFIzHuFBuuo3lIo0+ 76Sj4kRLLCkaUoYRUX1hlHb3sgODKm4b3fotdyzSHwuqWHqIFGgBoxSXFBUlSIAZEiWX MKN3DlwYDko+6HJAiQmDAnjcFAcqJaCkitZcNR7ddDslllqN2iPhWgQk4w7TarvSv9xY kf1UCtQWkWyzIDX6ligEvmxW2bZwQKcOLbHqzA/9I1letcyNCgA3AsbnVdHyoui5MUxJ KRWA== X-Forwarded-Encrypted: i=1; AJvYcCVKFsCSWXc3Wx9FJFwfNd0FRMbEJ9SMbk0nfPoH+1XA/4eE71lcTkMryIDVXrcOne8SJ9mseCW+oAP6kyY=@vger.kernel.org X-Gm-Message-State: AOJu0Yy9HSbZXy2EB7yk4hQ3sMr6lg0TwET1xgAEFIyJsamiuPUt4Izg UD6nA4LkxbwHRvaMrtBOsdyNNRgha31Wc7ziOjaV2ZB3nfxarb5oqyu9d2OZPAqtVHU= X-Gm-Gg: ASbGncvBVkZaMRICaEuCSpr18Uhf/idV5HuDf4XYUhWCqPO9LGaM3pBg8UNQvvAIHeW PuMRiXdEO4GQZeimRNJF+AcchJXvqn7Fel+aY+A3IAa9SZQx2EqH48ixHC4oTOBeEs3WKGwcCgY DXUSj4t3kmT11rlVJrPFtAcLkkThqppqiC39qlu8qf3Tdz7oscJea7I0Vg185E0WhiPdVcKQO7k Ngc4+YxPTi/f0dKnFDM3108cjasZz61zMfMr3pk0RNnjtCGL7+CCpSpG9M7kTJHcn9A/UK5f9N7 vFMlmhvrKQ9nio8I+Pjgb1T6YTAyVlLtA6SuPo+JHjrsCCnlxrqa6zL1SRP+fY0/EhHpJang9up Zq9dLcksVq01CVrSjRvIQGWpj0trinkB/7AqNFlgqyHwcdpy+HApmj4e6lTcot6siRsQ= X-Google-Smtp-Source: AGHT+IGpKMpu73nkeB94rPHaIZutixTAdFFPa6qysCajDttSQ0OQGd/OBq10tj2PVKg3TstrN7uRIQ== X-Received: by 2002:a05:600c:4f91:b0:46e:4704:b01e with SMTP id 5b1f17b1804b1-477870708e1mr27099245e9.8.1762955742150; Wed, 12 Nov 2025 05:55:42 -0800 (PST) Received: from [127.0.1.1] ([2a01:cb1d:dc:7e00:2a6:e453:42d3:11]) by smtp.gmail.com with ESMTPSA id 5b1f17b1804b1-47787e2b835sm37711685e9.2.2025.11.12.05.55.40 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 12 Nov 2025 05:55:41 -0800 (PST) From: Bartosz Golaszewski Date: Wed, 12 Nov 2025 14:55:31 +0100 Subject: [PATCH v4 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: <20251112-gpio-shared-v4-2-b51f97b1abd8@linaro.org> References: <20251112-gpio-shared-v4-0-b51f97b1abd8@linaro.org> In-Reply-To: <20251112-gpio-shared-v4-0-b51f97b1abd8@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 , Bjorn Andersson , Konrad Dybcio 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=1141; i=bartosz.golaszewski@linaro.org; h=from:subject:message-id; bh=fe01g4C6qCSbAEu6zmke8JCgZ5Eo9dDIwKAhmTSay1w=; b=owEBbQKS/ZANAwAKAQWdLsv/NoTDAcsmYgBpFJHVBTDDrvJHZ80xPG9a4F7QqcyJzJgbcSXHa oo9SZzZ15CJAjMEAAEKAB0WIQSR5RMt5bVGHXuiZfwFnS7L/zaEwwUCaRSR1QAKCRAFnS7L/zaE w91FEACnpe+vPiO9uBC+BsokWIYfbDME+aBKEozY7SwP0GRthdoEWwpZO7sgtgsDqvbBiW27PQj u3dNIE3sC+Xq4qVOYGD1CwpgZRYk+nWkm0G/rdY9Cdt3WkjzDjmRKQ6nfYxQ8QCUe3oWOHRD2aD FIGPCTly2E8ANXYEWTCdTDIlSifKrLDkfDYoiYC4zvzVFh7yfTrfN3OorFzIpqoBDiFUdOF5v4R kZXRmcAik8hp+cSw2IqltJYa0IpkM3fi35svUUVAiaLFemUnTXLwinqOdZXoAR3NUUIkg+yfyGT Ng+kpi792Y0jFdeMbPRqb7Brix32Pi7kA6zS6AWsT36I9rQzC1uWHWh10ar6IO4g/0eihjuFPkq lIUPxsIpKrOIaKFX5oLZFonmQNcTu/QgsBF3WvKDnb+soIUb4YRd94DdPk93QpQ+YX0A+xvfNvf WxDOUFlr8mhOjvU+AbCZTnisyN6TBs1WfXYv2BMxjlOki2kzA6/hsumjEZ41oXWs/fNBeAOSZiV uAFemOSTTwgXTlYdblMtR4YBxsA+hUnf62j8isuIFTVeDl04b/T9Q6CDK87kqWqQNOrJgJL27OE djN1+y17ilgzoN87pxNZICYpjc2tighS0XY2870Hyn8BpJTZ2mwyf627na0bY0v18oddUykWYfU xrHzssrVMLnGRhg== 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. Reviewed-by: Linus Walleij Acked-by: Linus Walleij Signed-off-by: Bartosz Golaszewski --- drivers/gpio/gpiolib.h | 1 + 1 file changed, 1 insertion(+) diff --git a/drivers/gpio/gpiolib.h b/drivers/gpio/gpiolib.h index 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.51.0 From nobody Wed Dec 17 12:14:28 2025 Received: from mail-wm1-f42.google.com (mail-wm1-f42.google.com [209.85.128.42]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id AF4A6265609 for ; Wed, 12 Nov 2025 13:55:45 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.128.42 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1762955748; cv=none; b=sp31DmMgcZedwF841KERrmJ1Sm6+ccsmNa2qGwr1s/9MZmZqQDYlmuqXSyEoxuUt2R73wk4MuTd+8YoksflLrVztU0ID8x6dQBWHSvOU5wxr0MloYr+hY6brzPruDUg2bqGwq9jGsvbHbNthfd9yjI6XENG29b34jol+FzE+R94= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1762955748; c=relaxed/simple; bh=en1OCTYsU/wC0ciRBSnmX7Wpxzjfhc9j6Jstyzo3nSI=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=dWZiFMgJYSRLRiT54SfVtMZ3da4GuwtK/BXcv55e0QRK2QVnn2QLGtdpEBvej+ogVD+YEzi9pLggVvJJ3sQLXWNN4vkLNFs5ZlAA3QpQGQ67dBFbM836UCG0/i2Q6gJm1S/e2o3TFDS8U7yB3xuo239NcSG5gxMAvQ6yNJHL9QU= 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=ZrrncgSs; arc=none smtp.client-ip=209.85.128.42 Authentication-Results: smtp.subspace.kernel.org; dmarc=none (p=none dis=none) header.from=bgdev.pl Authentication-Results: smtp.subspace.kernel.org; spf=none smtp.mailfrom=bgdev.pl Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=bgdev-pl.20230601.gappssmtp.com header.i=@bgdev-pl.20230601.gappssmtp.com header.b="ZrrncgSs" Received: by mail-wm1-f42.google.com with SMTP id 5b1f17b1804b1-4774f41628bso4357555e9.0 for ; Wed, 12 Nov 2025 05:55:45 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=bgdev-pl.20230601.gappssmtp.com; s=20230601; t=1762955744; x=1763560544; 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=bU0p5jhyAkg+9M5zCJdzo0UOszCY1ZswUrkywMR8tm8=; b=ZrrncgSsj4x5AM7AD5OOmGA+t9peyuZ2rq17yrfG6/nIp+IXtlfwXM2FPFbTg5kg2s 5usT2UvSAPCtfMN8uRBAnMpHu9G7LoQYMzIpVInK1gAcbNNwry1u/NNMOP7Ul9TDSEeQ 3IQ7omlE/hfhRvHXxxrm1EscaZESiweiB8eVNmfX5Pp/5907cdKe5+0PAdBdfY9QuaMO emaS7OV2DA8WJM5xdfn2n6BE/tYoBTQ9L1rPYmvWPncsNkVaBsl/UODTroKrG1iPhkXW ymlwPT0+epozRmsSOpBOZKlOmfnZ2sTXSWVpLMxlpL6eULRDfTvQcUoDxGiHdYmzzg2V i0mQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1762955744; x=1763560544; h=cc:to:in-reply-to:references:message-id:content-transfer-encoding :mime-version:subject:date:from:x-gm-gg:x-gm-message-state:from:to :cc:subject:date:message-id:reply-to; bh=bU0p5jhyAkg+9M5zCJdzo0UOszCY1ZswUrkywMR8tm8=; b=bYG1KWh/ZaokxWDqofYZilELwlJUimSZ5Mx9lU0/zP39WjB5p6JbG8RBzsEO4k2qBw 6BtYcr/XsxrBmRaNZ3URnkauBJzq7Tbglsb2gGq9pl2+nwOwuNkPEa5e3PPuXxz1hy6R 73/J4BWRS8wuQw40vqwTfuS0v0xl/QIuTSX8wA3nFKbnoa9ltHWVkdFQOwHMiwhok2WU AU7vYA+i/U86o9jLkwqpRoFX1eiLv5YRkC+ADFsxFPiqp7Jd9BE7EOrX9fnR+JBbu0GY V4KnH9TuTMWTRaBHdNKYh+fOV8ujqTktdVVy+v+rdGyqYKG8r4v3maInMHVWjH1tOu06 tsTw== X-Forwarded-Encrypted: i=1; AJvYcCWr1V8lVm3h1sAF5dIYSojISQoH9kUn6d9D3jgap/A30jS4/MHXLhQY/jCVE/iAbmi8XrW8X+tbZAX1gEQ=@vger.kernel.org X-Gm-Message-State: AOJu0YzYsEEjIZTqFwbpCARrIHpB6pa71M8TCJxLppyjq433fwBFRQE0 CFo4CSk7ksZTU8MB8FLfHJw2YvH0dCBRxSqlGuin+a7aiOhjjYrCcv5JY3PSv6pxZmE= X-Gm-Gg: ASbGnctEaEDa/tPoBrZgsc6PikM8YlYuhMK8lm4Ps90SheG4eDa52e3LhH64vbCcd3F 4h4+1vySljMvYy1PaaXOiWP1BqpadJFvM7HlnoapsHppgvmowtnDihRYRviRA38oXKoy1przy6q yHWaMm54I6uj4NYufBCRmj0Y4XWkvabBJwR0CNI7nAlcx2Xq0HZ1OVxiDWexSH5kjAbofcPKhD5 pzrBHAt0bDMBHX1TnctbYRfqXnaKjZjy7Fel11UDaTh7uvyaOE2IL8jc734hzMkwEg6uUdLr+z0 hENkgF2pjl5drqRPZf29AvSpQ6SBE29pjNcUlDBE5Y24MBc/JHyR/rLDha/sZuqpe2ob9oX3zaw BZpveOzjDP+ykKtKyCXCXb5EUR01t9noBUxFkns8Mwpel4E1ujCigCcO69RE+tRDa0pc= X-Google-Smtp-Source: AGHT+IGjwTXgphW/quEnGs67bFJbXJ9C9T372lL4McIb3rt4uORpNQqnqrGlLen4DAphFbFwLbGdBw== X-Received: by 2002:a05:6000:381:b0:425:6fb5:2add with SMTP id ffacd0b85a97d-42b432c933fmr6469629f8f.19.1762955743952; Wed, 12 Nov 2025 05:55:43 -0800 (PST) Received: from [127.0.1.1] ([2a01:cb1d:dc:7e00:2a6:e453:42d3:11]) by smtp.gmail.com with ESMTPSA id 5b1f17b1804b1-47787e2b835sm37711685e9.2.2025.11.12.05.55.42 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 12 Nov 2025 05:55:43 -0800 (PST) From: Bartosz Golaszewski Date: Wed, 12 Nov 2025 14:55:32 +0100 Subject: [PATCH v4 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: <20251112-gpio-shared-v4-3-b51f97b1abd8@linaro.org> References: <20251112-gpio-shared-v4-0-b51f97b1abd8@linaro.org> In-Reply-To: <20251112-gpio-shared-v4-0-b51f97b1abd8@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 , Bjorn Andersson , Konrad Dybcio 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=18980; i=bartosz.golaszewski@linaro.org; h=from:subject:message-id; bh=fGWc99aevRaj31ao5XoPsk2kEtFdFEMQgrWVi2eCMFQ=; b=owEBbQKS/ZANAwAKAQWdLsv/NoTDAcsmYgBpFJHVbPA43EaseVfSX0YKeV1n6c3lUytGFYKMQ qOR+nIyP/CJAjMEAAEKAB0WIQSR5RMt5bVGHXuiZfwFnS7L/zaEwwUCaRSR1QAKCRAFnS7L/zaE w0yED/4hGzDn9JtFjJB6Rl5hGCn+zz3FKZowQ9V+bLXrL5b9DBiC6tWBrmTCIMVYXWsT0pQz50X VKWVeR5j6UKhmVXdxRFcLSya1c+lhgnobKVAGnt0t95dWeJbWuF1tJvqJpOsTCvExH1UKzsmz6S u9Zs4fC99CNCaQWQnQsqzAMjwZUZ0z9pPnpxZemZ9LIa9gd32X0BhGCDOkAl8yFj4ree5Zq4U0b euGkmwlZiEhSUlflf2mBeq7PhE76YaQMIF2H4kgGmqaR3kzshivWV6RW0Av35o17SfdMeDMa0lE zYLrWoasrgeULHqLUJd9AG4/w9jY/chzQULjh3fgjD5WEX5boRORQeS/OnJHaTirktJRWvsY//E qropO7m7VMaiHVyhbDOJhL/hcRP5IQW1unfYF4g/yaZfz2W5gpNAoVheti14ewwDNbRtW8nmRvn Ihv+FbYXHBSz8+0T89x5CTHgZLFtpRtqKsaOnjOgf8oHZBUiikB2xRKRyZ/i7wBKjsIxP6tToh8 r7LtKd8Aupxc5cF5NYj8MrUal/rqSJqh2OZEMP3x2yMx7S3Dv3kP7sFkcGjoUmToBAsA9Gp7ueH fmOcjDHbG/Db3x3uwcFt81HDnC1ZNOxR6wgsDXIU8jbN4y0MUGqMsJL7z7D9pdMjNJROKse9vDt Gw97+dAd3rrfM1A== 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. Reviewed-by: Linus Walleij Acked-by: Linus Walleij Signed-off-by: Bartosz Golaszewski --- 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.51.0 From nobody Wed Dec 17 12:14:28 2025 Received: from mail-wm1-f45.google.com (mail-wm1-f45.google.com [209.85.128.45]) (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 A0D3126E706 for ; Wed, 12 Nov 2025 13:55:47 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.128.45 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1762955750; cv=none; b=CKfLrvZl2fwnO/lAInY3IZvI8j/GIyHNWwOsQhn/kt5gOzB0I69QrsiwxFkdm9fsvPOjgQBmQaA5vas9L6gsQ8Z6RuD/A/oQ9HXHclObezfxJuxcMp7IZqBHZ4qPYyq7nmvczT9nsQpGQ5ce+sdojfDYQZW6Uy6hS49om1Qf3V0= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1762955750; c=relaxed/simple; bh=oTUYMsdG/IVDKhQ3B77Q3TRt2359OvEG4o2hpeKnoPQ=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=hAxAwqCAMxEwTr/k96uMJFBF11yc1Unn4kxEyGoMzrafMi2j1loj3S07LRjTkCtXk3ZGVz9uI3qvqMeom6B4/7NCp4J6MCXPN7RL/YoupuhSKOhuP2fy9FhuS9R0bgEUB3tZ3L+JVAWmHiy2YGV+lZ7hImCJmlyQJu+6Ugm5Fxc= 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=AoblrZGB; arc=none smtp.client-ip=209.85.128.45 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="AoblrZGB" Received: by mail-wm1-f45.google.com with SMTP id 5b1f17b1804b1-475ca9237c2so4904005e9.3 for ; Wed, 12 Nov 2025 05:55:47 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=bgdev-pl.20230601.gappssmtp.com; s=20230601; t=1762955746; x=1763560546; 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=okxpEuXb1rioQLTWx+EehnmQO9hSAr1CFW8NOoMs7fs=; b=AoblrZGBoH9zIkUhPp9D2ErBCpW+AAvvzTckmDfAXP0YUBOqTQewEU769zHAQa2lAu WgrRiGbM31XF2FMABpv0FtqOmzsGzmeeQv0Oftpr8jkGJc8aHHGCdV0MyIIlvE0wE56t EHpbvhnY7FB03Wj2xu4bNDUZZFQduOIWBUfWeKBV8+jip7Tqp1Cfnkvg1uEZVtswl6eg T1J4ibUtz1Mj3eqmgGUaUMVwi1NpzWZi/Swls/TOgDo+4z7EQEFXB0gSHuf1SNPIxcC4 R3/JhRyN1GgwNREEHNn8S2mbIMxUOU8ywQbkBhpbURIQwKclza+i4i+oAImEeNdDtu5+ w9Cg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1762955746; x=1763560546; h=cc:to:in-reply-to:references:message-id:content-transfer-encoding :mime-version:subject:date:from:x-gm-gg:x-gm-message-state:from:to :cc:subject:date:message-id:reply-to; bh=okxpEuXb1rioQLTWx+EehnmQO9hSAr1CFW8NOoMs7fs=; b=xINWMAaTviwqAWZg3nscaCxLQJTq7uxYdBCctAdEg3B92Fo4JsNPkEnVjHrWzXunXY qCAubuu3T2h47jncw7lK9LSNaqvS7RfdYne1HuMvGRUT2nY69RKke8+WmSMbVUIkHkZ6 DKAu5579l0oblrVyOt3sMPU4qFcJcl5YVCd0iHEs71GgLijtgHKthHsHptqPeIsI4HdG JX/WFStbZ9ynQ1m1HF/32a/HNLRsTB1UUIEuGfOXRyisonu7jyuyfxRO2xp3S0uufq8M +PnQoNSTrEL5cUaoqnEzgTyivKa6aqMWxJGbaUtVWu05Y4wm6bNTZkU85+8wrkv9cmaD JUZw== X-Forwarded-Encrypted: i=1; AJvYcCX/eYtqZ/8yhjSWiPVkgJ4/xHf0vTCDCaZ08mnLVwVa1XBu/3cqbHdi308EHnTR/DZiVRxhOAwnujlNeYA=@vger.kernel.org X-Gm-Message-State: AOJu0Yy/Z3SV8QKU1Q1qQy/OioUy058NmRhCkHRHCd5N8jOse8l5P8PK PqGgqC5AOQEcQFHm1O6Q6byPIYxE4GJKtXi6lMgNOMTMQm2S1aSFvo6Ett9Xo69Hbpc= X-Gm-Gg: ASbGncvvtTL+M5J62hba3WIxB266f44zu1pMXuQCd9pOs6QqrhxTGKqof6+jm4Zk6YD IPwGZQFqTkMrB46MvujRWOa/DGX2g9Q/bFXOY7vhO1oSpfTfKS79Yb74L/ADDeCXMs+gQZhVej6 B0YZkxabTk4mwPKpTl9HsuOdci5Ci7VMEByxn7R5KFx4sce0ZD6unFBe/E1is9/nZ/x7ZP3hRqM nej7rGZRQxDEAO+wA1C+dgTGJmXdPNZepa+HUDI+PKCzwXj2qJbwPOGTY7QWSm2PUxK7Azt63sV OJRyGh3MMtWE5dJ/9kFGYK7GFS4iRzqP+vxwoQ2LKMKGT4y10FSNC/HVabDfJ9o/pMfLkl0BCxb ex0bvgpEYtvy2qcp3uLb5VPVHcN7jZiVlRSbQ7kVqQ++E4nMCIS5dxdbzcTGAjIj8YnE= X-Google-Smtp-Source: AGHT+IFrq4LOscGgyiaHGmHOOTxjacCxX8HGFaagLmdraJ6fFxhX4nYpJwcLo5aDxi19wWPTXZZRRg== X-Received: by 2002:a05:600c:1c85:b0:477:76cb:4812 with SMTP id 5b1f17b1804b1-47787000e64mr32508585e9.0.1762955745795; Wed, 12 Nov 2025 05:55:45 -0800 (PST) Received: from [127.0.1.1] ([2a01:cb1d:dc:7e00:2a6:e453:42d3:11]) by smtp.gmail.com with ESMTPSA id 5b1f17b1804b1-47787e2b835sm37711685e9.2.2025.11.12.05.55.44 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 12 Nov 2025 05:55:44 -0800 (PST) From: Bartosz Golaszewski Date: Wed, 12 Nov 2025 14:55:33 +0100 Subject: [PATCH v4 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: <20251112-gpio-shared-v4-4-b51f97b1abd8@linaro.org> References: <20251112-gpio-shared-v4-0-b51f97b1abd8@linaro.org> In-Reply-To: <20251112-gpio-shared-v4-0-b51f97b1abd8@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 , Bjorn Andersson , Konrad Dybcio 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=12178; i=bartosz.golaszewski@linaro.org; h=from:subject:message-id; bh=0FrWcL7+b43kJTdQOvLH0UXC/dEHaWLrwVCfSK/xBPY=; b=owEBbQKS/ZANAwAKAQWdLsv/NoTDAcsmYgBpFJHVf+xVOt8uIIE7Q3GL+Iw/0lWC7Onn98eAr Q057KyMCyuJAjMEAAEKAB0WIQSR5RMt5bVGHXuiZfwFnS7L/zaEwwUCaRSR1QAKCRAFnS7L/zaE w2xdD/0YjJ2WVr1x7Md1meYTvfYwZL+7Z/SMjXxODil5PrnPx7Hv8h9QcUoxqYym2nQPi4ON2aA 1IZxll6V80bXl4X99ItUTRNq9xaUIZ8Ayr3cBnLrGmmSeD5lIYgtgM+dHnMFIbXjyZsYQe49WXJ dLRQTs7Gc5vmoNHgF4YKt2bPoxD9JMAR7OU+PcM8twtXLFuXvpkaifEiA4yhpVcQcIOpd7KzCBo MWsqdTnOQHOwyxuS1/9x65Tp6ArxVY0Y4zTr0q2cQHhvgbfcRlqEmGQ81Kl7xbuhKhAsbbywKqm +nOcUb6qA5SKj+wgLsSp3Ufyg3JeiOoHuvLdfiSvGCaeoFyYtc9oVFukSr1ejYPZX/XzZNx0Pgf f8C+tohg8JQV0zVIHB7xh5z2mQD1aQQGbjCyQb9bh69ry8N7KJKzQZlPuidh8C6Be6EAjo/a/dq pmJk5/53afBHz5YciwGbJ5Lp5vN2GUjVZbe1RujsVjNr2r3BoQPHsKg9FY4rQM2jiwQOUl2Ojz/ T5G6kJOSm7Kvp1/d9p3TU2fLbwgbMh0FLOpS+3OeF3IkjVkU8BN3mlyIT6LeWyyYUh97neuRjJA ikUGW3EKjXCkqZM3E8B0wO6c5yla0AddUYCHDkMTXsXNhB7JRuQGCpxJDiurov/XS8JObvZolQW GIoPLoyHE55tAvA== 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. Reviewed-by: Linus Walleij Acked-by: Linus Walleij Signed-off-by: Bartosz Golaszewski --- 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.51.0 From nobody Wed Dec 17 12:14:28 2025 Received: from mail-wm1-f43.google.com (mail-wm1-f43.google.com [209.85.128.43]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 6C68E26A088 for ; Wed, 12 Nov 2025 13:55:49 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.128.43 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1762955751; cv=none; b=NEYm8+WD8L3i611dT7i/dc2L8mRLZARfPQMDYZz2bJDBDvOsRxGZHMkytCIIoKKMMGDPXFTAfBZRx3PcnhZNarDK9I5J2AmHuvBnioTqZ44/so2Pgxw7T+NfzgMrWp71lV/FAxD01njnbeTRlY/ba6V9q3gUW8C38p0k/WCtiJA= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1762955751; c=relaxed/simple; bh=3Y14NIoJOg2A5e7NhoQrMadfDwtba7VUZVWmEJyeugk=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=uT+x5vWsaZiRppGGPCStDuEw8tYXPNzrijG03hvhfDU42oVqWqt9NIi6ZwX8PLxVoPPEyLpEpLniuSVcscIZYcdfp/RVfgRU5Xp5GrTYzaT8ngt5kB84aJFtEh9WxFKIiYxa8rSU/FHn1nt/hxOHiN2nQEWrsIR2sruF9sZBTh4= 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=PbsGWQfA; arc=none smtp.client-ip=209.85.128.43 Authentication-Results: smtp.subspace.kernel.org; dmarc=none (p=none dis=none) header.from=bgdev.pl Authentication-Results: smtp.subspace.kernel.org; spf=none smtp.mailfrom=bgdev.pl Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=bgdev-pl.20230601.gappssmtp.com header.i=@bgdev-pl.20230601.gappssmtp.com header.b="PbsGWQfA" Received: by mail-wm1-f43.google.com with SMTP id 5b1f17b1804b1-477632d45c9so6385915e9.2 for ; Wed, 12 Nov 2025 05:55:49 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=bgdev-pl.20230601.gappssmtp.com; s=20230601; t=1762955748; x=1763560548; 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=iHDkpdBIkAui+sOwURBjRa8uCHeO7j00sh0QVBNbm7E=; b=PbsGWQfA4H06UhRh32IW9v7MTskc5QHUtTH2+8zjyeC37AYNR5LlugNC7R0NyXBFCU 0j8wp3JXNxrZ+MfqyocPLBH7BAWPZ5p3QCGRR+f+YaKXMtggsg/yWBKyfa7MxdoTf+4K MsLHHHGY+mfoap5CDI+FBRe+TVlORuwREQ0sE61LLBQHCa9YfTzYzabqJH+NlmYqHv0w J/ff++E+6Ej5C1jnZeeUhhmpK5jPqrlwrMUNCPG1Lod28j5CJ3MAjY0hsYRigkZ+5cv1 rYbnQNPQcoFhrP35O9aYFgxGkRYA4VZgZjU9dAXOxEMb/R23ECihOIFWat8gw+wheIXM Of1w== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1762955748; x=1763560548; h=cc:to:in-reply-to:references:message-id:content-transfer-encoding :mime-version:subject:date:from:x-gm-gg:x-gm-message-state:from:to :cc:subject:date:message-id:reply-to; bh=iHDkpdBIkAui+sOwURBjRa8uCHeO7j00sh0QVBNbm7E=; b=mhaNjZNM5TR2I4D5hrWNUtkXzuQFlS6noXYsB6Eq3LE3wsGlhcJO6c2gvbLj6qESNB vz4dD0rSRY4jsdQ0c7Mial5dTezEZPI6eZHOZcnUDkhcf2Ft/aKwaHzV0mxP3W+eaHfs XfeTCjBSEos8mquq0q7fiBJlBqLkBVBjLYO/MAQuvPpnL66+8fLMJiqu766keJxz2cxV EH1ZBWE+W1NsQS3oD4gIS+cn2Q6Zl+N62t81BDfllBKDuCeWCUbNfvpnv9b0uuzYFysZ 8XmjJq6s3/4RWVMXOyRhENtCSf21T4jn80a6KIR1NQ+uCe3e7cGZxdk2HkggjMqxh0ke j9lA== X-Forwarded-Encrypted: i=1; AJvYcCVCU53/GtuKyJg+mELqupraE6ZOClc+g27Adg7QyDie++CAMVFaQWQhI0S2myrSvWhKzbcK7sGSbI/anyM=@vger.kernel.org X-Gm-Message-State: AOJu0YzKRbe5YY24nRHVIZcEy5UPTPbbKvHp/os/VDDMzySGELboSP4Y N2/GzS/Uuo+xn+p5I7283RVPuwKsz1voZG5OfvhWc973lCm892xh3ypZzemo7Dercts= X-Gm-Gg: ASbGncuBl5V5QZCx4syXtgpB/sh6+E1gvJmSCF99HlQIT9t28J2oYRVwm91eZtVh2Ce b2+YSZRkxIH35IyWxfE25OxIK87jFkYU/Lt/YhyWYXDKjdfdS+wNWGHR7aqT96Yu99onna3jm1d pdfIZ3pWyUVEyu+UlVS7JwjYE+YiD3Xny3qOsSTTtNEMtTob4hIOQq2xd9q8nXTXq1SBOe2Jf16 pI1btJJq2Bk0+ewY9nPoH5Z65cDuoCMdyoWwsc1VbYWXcfQtEi2bWY+Ubeaj8/9YsHBM7+sLpj5 vygZzdl8xNyeC1EkyuEDF2d9ddfPZahGJB+G+lyGTuRZM9QJixVZp/xK02brTvjA/2LDA/OzaP+ tJrMGWxXerWL3owM0CU90byLMFQzx2dYubp9VL9tock6uXhFkbbTPMmUcVzSM6eIx9V8= X-Google-Smtp-Source: AGHT+IE1m/lfGGA9jUE04kJURKhYINHzlwKRis11jsG5v9Y4unsiMKmAyG3c24nrHJCwH+vPFfgVMQ== X-Received: by 2002:a05:600c:6305:b0:477:1326:7b4b with SMTP id 5b1f17b1804b1-4778708e66bmr26506715e9.19.1762955747543; Wed, 12 Nov 2025 05:55:47 -0800 (PST) Received: from [127.0.1.1] ([2a01:cb1d:dc:7e00:2a6:e453:42d3:11]) by smtp.gmail.com with ESMTPSA id 5b1f17b1804b1-47787e2b835sm37711685e9.2.2025.11.12.05.55.45 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 12 Nov 2025 05:55:46 -0800 (PST) From: Bartosz Golaszewski Date: Wed, 12 Nov 2025 14:55:34 +0100 Subject: [PATCH v4 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: <20251112-gpio-shared-v4-5-b51f97b1abd8@linaro.org> References: <20251112-gpio-shared-v4-0-b51f97b1abd8@linaro.org> In-Reply-To: <20251112-gpio-shared-v4-0-b51f97b1abd8@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 , Bjorn Andersson , Konrad Dybcio 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=4529; i=bartosz.golaszewski@linaro.org; h=from:subject:message-id; bh=AmdhmrGwNQekKUZMok9IIzwjRaNxDuviwqIp/MhPR5A=; b=owEBbQKS/ZANAwAKAQWdLsv/NoTDAcsmYgBpFJHWryXicSatd6ZW0nliwok8A3Z6ggfafAewq EZ+P6kfOlWJAjMEAAEKAB0WIQSR5RMt5bVGHXuiZfwFnS7L/zaEwwUCaRSR1gAKCRAFnS7L/zaE w0/ED/9OB9/L38MYlq9i08Z6GeffUbPMAcKM3KtVy4fVrmm8NxkDb5fdangJdaI4cz6n6/TI5UL qMnmJhYHDPim+wIGI6qxRNUQSfynPXGp0/YO/wOg5dj+xBn+m9KBNCDH2sFxkcdLn03FTgBAW+/ Ch3bG3mod1OAlt9ryvejRDUL2P9HR2jHd6FQp5Fjfs8ItDBBS+hG5W5sshAxHZmy3o0X1XsTdP6 kCUHpraGJcWd2nGRbKbCqCoQp/Nt5ANyOhAL8o6QRAwrR5GIWTl4nZkt6cTKwjFiJCXN14bhbt9 xfj4ZQuZ3F6WrnJ0hGxeRuTaoyfZsJQVKo4aeAkK8W2gyuVY9xdiGJUcga0kjkbPyjiaaF87Pk1 vJ12P9kc+ijBk2SY14erx7PceZ3ll2fI/TEcIXHsEX8ZccnsGdziL2YS5UiEni5LXPhN+yY9MnF Qo6XuQ2AXh8w4LaH8JsTr2eHfQ92UT94MW+YP/Ni2QR3eHP+PS4gQey2IUV5bVeQhoMR8bysXw9 1KpsS01+LicdwF4aL+v0AwdrwMbYTbZV5Yy39Ke9NRvPq5BkL0MB3wGzIxicLSHUPWvqIFDrshp rpyJM0p0Go8LIqNqUq3CR1DoBTtwVL0DWTQlRSBb1AfJ2a7X725/0qydGg/zQtast9HfIloE/NV /RT9pvuSj8nMpaQ== 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. Reviewed-by: Linus Walleij Acked-by: Linus Walleij Signed-off-by: Bartosz Golaszewski --- drivers/gpio/gpiolib.c | 50 +++++++++++++++++++++++++++++++++++++++++-----= ---- 1 file changed, 41 insertions(+), 9 deletions(-) diff --git a/drivers/gpio/gpiolib.c b/drivers/gpio/gpiolib.c index 3659acc600d9622d5d2baeb055ac083556f344a9..c59fe05c838e073b4bc99c4a766= 7cb1ff40c26b4 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.51.0 From nobody Wed Dec 17 12:14:28 2025 Received: from mail-wm1-f51.google.com (mail-wm1-f51.google.com [209.85.128.51]) (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 ED94B337BAC for ; Wed, 12 Nov 2025 13:55:50 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.128.51 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1762955753; cv=none; b=MrNtWeZf/wL33AI2HGBBT+7Til3MEA4Rr+tX+7tBnymE6wpD5ODX8yvJrkdRmuAwgGEnRk4bpAz/DveBDZJMWsUj8rlF57Qd7lyTMthCNzByE7KnzfyVGik6gcxPzIaV5F/Qf4xSBdd0GSXGjAn2r+7RZ7X236j9vGO/Tyny+Ao= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1762955753; c=relaxed/simple; bh=QD6mLhmU5x+wBz3cjbrtkC+qGfrTopjdkBF+9DflXwU=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=BcoWWRFMTDxLM7iH8JIUBBnGfIDPOaLdqvIZrlAlvqPG4NWR5Rczw00XIM4jaZPf6y62G4VBgmlE4wVJULIXS9F2NwnoakNPT+koRJpxVPTX2FEUaHhO8a9wFs7KFNGJN7nCXT4+jqUCGEDd5Kpa38B6Qx/oO7de4cw+1ScpmP0= 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=G9cdtQQ1; arc=none smtp.client-ip=209.85.128.51 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="G9cdtQQ1" Received: by mail-wm1-f51.google.com with SMTP id 5b1f17b1804b1-47778704516so4535005e9.3 for ; Wed, 12 Nov 2025 05:55:50 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=bgdev-pl.20230601.gappssmtp.com; s=20230601; t=1762955749; x=1763560549; 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=uqf/JX2L7LJxSdDCATW4KSy8LDgu/Cgd29UQPhypHSU=; b=G9cdtQQ1YZnO4Hg+LaiYa/oQKY6AVRB8+suvDjiCT+MJIXz+pNTsErPllL5qRpzDXD ixZZpIv8pLhEwSHQbhGTXP6GjpoR1giPT9ibRN8ZYuXITPIws4WijFL5zRjzYodTBTz6 UURLhKKtYvDE2NDchvySwxLjBX/7Nw/HCqJK/3n0e2FdLmWKXZHdhl4FpY30UqlgDaRZ +k81t73BF/9bbHz9r9P7qQL+xQZzbkoNyygg3ntm0MdPi51RRSOAsTYUa2Oqrp5IXUxh hOYVNPc9/BRY6LA8sVL1IYar8wkzI43v0H4lsyZXIW4ZuS7GhK+BU30eizai7gQNmrDm YKSA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1762955749; x=1763560549; h=cc:to:in-reply-to:references:message-id:content-transfer-encoding :mime-version:subject:date:from:x-gm-gg:x-gm-message-state:from:to :cc:subject:date:message-id:reply-to; bh=uqf/JX2L7LJxSdDCATW4KSy8LDgu/Cgd29UQPhypHSU=; b=LicA8BogWU02hcMBk7GQQTgsZ9tp9qVweNcu9ShFIDdaDFM52NiMRSBq6iehcH+6lM ZrlGBf0aLCNfXdpEpMMfvlMKodA2y374vUh2UIwl4NgI7qQMcUVRpLcQCX8d5hYLfc15 8ojRxLLkMMvqdTUqYiqp2JT3rmSqBLMcisAIMLZ4L8m4eoYa6a+pNgHgcXrQWoH+u7xd 8kGU85TKclectvrL6eCicIKmoynmDPqI4bBKQxUFE2Nkk7TpsKwaVx1tAd5rGO/MsqiN uqodCbqFIPTnF6nkjCZLiXv8+ZVeoHoGyJuLGzul2kRtOhP6x1d+BeKlVf1lQaweVY+0 FJ5g== X-Forwarded-Encrypted: i=1; AJvYcCX6vsdJX8IWcMBj9IWips18jBGRDtmxFxjn+Q5TTywhf1QNbcrDsSWEvW0rEjxyRz2cnzmnR1IQAy94WSc=@vger.kernel.org X-Gm-Message-State: AOJu0YxRiuYFsotNYmPzzwyg42QO9UafwtAtkf/PpwW51KJmZfREW7P8 j9Gsa8RX7CCpaJwbQljEnnoi508GHj4hfFHXfhuc5GA5v1euZdFMud5f3+YQWVhXmWE= X-Gm-Gg: ASbGncvsAFiP2JYWh3BMvurcjt8C8XCOdn+O/nxpcQ8v6cA6342lCkKlNHkIGQe0rmx EPiWSqRQciZwwW4P0IX69v4EnjsfZlv6wJ8dT2cgYxX15ZUywDk3cEJRcYUArYJI5GwUh+XtK53 u1T4vDDz2m9BrPvK7/7xzhRpfW5sMKs7JIJ66q+wys3V+S0iU08PeXB6B3SfORcPTTyFHXYt343 QX7qkfdrdd9jk0yd2AJSkO+xPJRVQ7yuRchUpixKs81bhrLaMS16l1cDP1II4ERdlq7uFukItEV JB7VBxx2YQM7GpAMybanjymU9CH+/ZRMRI+EPKdoo+94IOgLJ5yKaNZcNHzVVKFl3PW4hgzmC07 gPCfs+a7z3B9LByAB5uJDl0ehYvhkWrhRNiLo/b9885IQKq8JBJUZEbZfzAklcScpC7M= X-Google-Smtp-Source: AGHT+IEFNNscHY36LRUkabyqy8pJkgvj8lmUeTc4bSwD2osPChT3dNC9Hz4duL4aGHcwmKNCJ8VeaQ== X-Received: by 2002:a05:600c:3113:b0:45d:d353:a491 with SMTP id 5b1f17b1804b1-47787044ccbmr30737595e9.1.1762955749313; Wed, 12 Nov 2025 05:55:49 -0800 (PST) Received: from [127.0.1.1] ([2a01:cb1d:dc:7e00:2a6:e453:42d3:11]) by smtp.gmail.com with ESMTPSA id 5b1f17b1804b1-47787e2b835sm37711685e9.2.2025.11.12.05.55.47 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 12 Nov 2025 05:55:48 -0800 (PST) From: Bartosz Golaszewski Date: Wed, 12 Nov 2025 14:55:35 +0100 Subject: [PATCH v4 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: <20251112-gpio-shared-v4-6-b51f97b1abd8@linaro.org> References: <20251112-gpio-shared-v4-0-b51f97b1abd8@linaro.org> In-Reply-To: <20251112-gpio-shared-v4-0-b51f97b1abd8@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 , Bjorn Andersson , Konrad Dybcio 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=4871; i=bartosz.golaszewski@linaro.org; h=from:subject:message-id; bh=rku5j8/61mOnZo3K42RMkCwcBTvPmLvpWhJ//UjCrvY=; b=owEBbQKS/ZANAwAKAQWdLsv/NoTDAcsmYgBpFJHW5VasetWt4Jh3G+BgPMs12efA7BJwxMkfN LcE6bdJIyqJAjMEAAEKAB0WIQSR5RMt5bVGHXuiZfwFnS7L/zaEwwUCaRSR1gAKCRAFnS7L/zaE wyd0D/9nnLMMOh4sABy5YsnZXVjgdMnmhhhkvdisFsVsPBV5TdVo/A7IhF054U2v5Uf6AF6M79q JKYRgvSvOiVoAK9cd6Go279E5RxLepgNj3QQeUZktSE7dYru17LTKqyFhuCl4nTbJBa4vKMFpZk 4FmCLE00GUkv9sFfJaTYmLAoM9bKTl5a5PCL/lzQlAOXeQNcW8nuTLFWQ5DjYj6NCXX1BtvluBX fGN2+VFE4s4ZG2eMA6SjZXl2Ld7Or34kZqrNk29UjtwLu5tHGZlitked6O287oU0aUDEOuOoe58 wuq0mXhxryoQoVZ5vaRLg6/nln6JZEiiNUPyA6IJr4d+xvhE3Y5A1H4pxDrDfBUPGCOc+mTPVqf t+KydMKuSENCE9s0hrAMkJXGfTq2XWMDfVmAk5eLqgJ8AOBcbvFUWuWvnClrCWJELcKLNXqJq7H k/YyvmMLu3gj04lAngDuLFhdostRkko2DGNlRe+qHZO3O4XErlCwRB6srlPh4jpjlzyrnBJLLSi ddeU7IRRp+5x+JvnFQFQguPXJfiI/UT5/gYie1UKRGbctmpjnwmeEG4GtZTXOCNaxV8c50oPVyi BjJodEz9ejOIsugiXzpWd7gGACNRr1Jmrj+Bi38K3wLeJLqGzlaOwsPe+lHRPC/aSKek5zBPSF8 1gKY7wU6NFDHO7A== 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. Reviewed-by: Linus Walleij Acked-by: Linus Walleij Signed-off-by: Bartosz Golaszewski --- 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 c59fe05c838e073b4bc99c4a7667cb1ff40c26b4..91e0c384f34ae5c0ed61ccd3a97= 8685d4f72e867 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.51.0 From nobody Wed Dec 17 12:14:28 2025 Received: from mail-wm1-f50.google.com (mail-wm1-f50.google.com [209.85.128.50]) (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 05B8E33A037 for ; Wed, 12 Nov 2025 13:55:52 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.128.50 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1762955755; cv=none; b=qOdRa5Ib8PUMZqjK2MNB0ujhX+m+A2jxg/9nSJX3nGkWmRDGF1thXrT1Md0Npuk5/VucRoUl6FwY/pceGhLvoUkDYqz2j/R06wLa2b7LqCekQcbn9oNeSmaSpAYNo4NPLFh8GUAgFJk/WRrIPSe5/54uOowAWhAqdw5wgtJXLVU= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1762955755; c=relaxed/simple; bh=SjuucycP/0Q2Xk30EDiwcJsYjdryTcHS9+y5uWbSXvs=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=M5HMJ39bgr2uDUnSQIo+o5dI6v1J/jEhT7y8Zi9lnJkKjvXHGs4+CGFn7HdcrzKj9Mp7LGdYmF9/oBKNC2mPbVgTWQ1+UqS6v9/kn7Vq8HcM8Qwr9T5YP4nBeRz2VmEOqxomWKhs5CXTrKNFTNqartKqPu826sqOnULxujSicY4= 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=peYjgCqc; arc=none smtp.client-ip=209.85.128.50 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="peYjgCqc" Received: by mail-wm1-f50.google.com with SMTP id 5b1f17b1804b1-47721743fd0so4933355e9.2 for ; Wed, 12 Nov 2025 05:55:52 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=bgdev-pl.20230601.gappssmtp.com; s=20230601; t=1762955751; x=1763560551; 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=79Q7HabNP3kse4nLU/vAYoWcwWnuSm1uGzBIAnSPTng=; b=peYjgCqcQ2d1Rhz1LjANgzHoPt40wgWy/YWTR9e9FKL8+bn4nqFOCkDKg3ZA8e/wNV 4beyRt2u8UyeQ10MCBNKmnJ/3ophvLmgk1n4KVVj3Rgr+pBzf0BQg314S73LdYD3C6+g 4FaJWgW88lUdUue+IBTcb4IOvnJ7iGJuVMwwakdccz/IEJFlq3k4q+29Ad/XKFBssCjm 9+gcJ1oydLy03/G4COAV9kmwyxXm+InBc7kndRDcfgcF43PVvSH4t8z/zd6SzCb0yUTE xy4iWiRbc9WdE7jTbXWUj3oMI7NhRogi+utZhSi3maixHZk9mxlY2rii1w9RfwcMmpZ7 rqKA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1762955751; x=1763560551; h=cc:to:in-reply-to:references:message-id:content-transfer-encoding :mime-version:subject:date:from:x-gm-gg:x-gm-message-state:from:to :cc:subject:date:message-id:reply-to; bh=79Q7HabNP3kse4nLU/vAYoWcwWnuSm1uGzBIAnSPTng=; b=KzwoXSG9QNVba92sY1I0ayaYTy3rqkGUHWkatw7JZAOFSSHI4TLJZjymarI70TBUA6 V/ge683eWPC0GPCM/486+Wk+vsDRysqMvIBT71/g7boT1DzxfZcjW3Xo2AFZ1eF95Up0 i7yya7WV268Z5f8RPZbHBTnhf/t4QdZvjcEf4faChJchGHztOdGasEyixC1om2lzrXj7 YW/sSjoxtLJ8Qw4ImawpPUO+8bb3RDlGQq6BcjSX0PmIpnkE3pNBSkBNpvT18sK+II0j TgrxevHCYelUC3UzdKjY2M77VcMdrHnZmr95cNsL6mJ5OYVNckqaxQF+BdW2qOy9EgQf Rrog== X-Forwarded-Encrypted: i=1; AJvYcCWEGaBSlIxw+XfUhbYbmVUBvD3PAZldamy0vXFdcgLEKT56M/dNvret5mNQhOpqs+NHoNXhy2q34aOEAtQ=@vger.kernel.org X-Gm-Message-State: AOJu0YxEs3SYmvgbAnEZtPrHO2bQuB+XTTdeLa4memaF6sV9YVmsKiiu ZbmrVBGLU03MS01IZ3jnML9lvljVEtjBoXL+1UV1/SIjES78KbFDt1lgRJ7dydYUlFg= X-Gm-Gg: ASbGncshe/JC0d5GdIllq4i6Vit5m7MtY1ncdKVEexz9ju5MVPdv72fZUBWoq+ZdrPF P41PMDDRWCvpak4RskhkKORaAwJKIt1ufZXPFHf5YQZ2kluGftqyKajxQB6iTdDSLp6rV6NyAox aeF+z11VMKiJ8ZOYPnZwPV/PAq1dDUvdaG8NBNFMzetzBYYH3VHzpMlWS7XKK0BrqRMo3kw9zqt Ev1VZ454OlPctPCmEaUYu87pNQx/eckKgUPm7e5vWc3EomPXh9nCO7rIiaXBh2iwshI5xH6/hZh b5ELgDAJrVDDDXlUPGlEJ5VKG7Y+bsnPixOZePJxsQEdRarSKt4GTWMX82VZ27JfJv/bQIirEzp kh2CImvyQ0KE4LSxCLaiBaJq3qVPPMT0KEFtxq+dwWyhBKxmNMbduqXBjmIxW9NM6iRk= X-Google-Smtp-Source: AGHT+IH/gUeUf4a+LjvPsAKw42U6Jw2pmBzvctQUKX6vryQGuNHC73dD3y2nVLgM1qQW+g7uw5YxOg== X-Received: by 2002:a05:600c:1c02:b0:46e:4e6d:79f4 with SMTP id 5b1f17b1804b1-47787085b43mr32791955e9.15.1762955751026; Wed, 12 Nov 2025 05:55:51 -0800 (PST) Received: from [127.0.1.1] ([2a01:cb1d:dc:7e00:2a6:e453:42d3:11]) by smtp.gmail.com with ESMTPSA id 5b1f17b1804b1-47787e2b835sm37711685e9.2.2025.11.12.05.55.49 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 12 Nov 2025 05:55:50 -0800 (PST) From: Bartosz Golaszewski Date: Wed, 12 Nov 2025 14:55:36 +0100 Subject: [PATCH v4 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: <20251112-gpio-shared-v4-7-b51f97b1abd8@linaro.org> References: <20251112-gpio-shared-v4-0-b51f97b1abd8@linaro.org> In-Reply-To: <20251112-gpio-shared-v4-0-b51f97b1abd8@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 , Bjorn Andersson , Konrad Dybcio 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=787; i=bartosz.golaszewski@linaro.org; h=from:subject:message-id; bh=90mV0HhkOk2X6mMXJGqXC5YmpVRGBZfIYfoK677b6nQ=; b=owEBbQKS/ZANAwAKAQWdLsv/NoTDAcsmYgBpFJHWKXa26OvbXIS4uHVQend8AfFjaKwOvW6+K RoSgKje/vqJAjMEAAEKAB0WIQSR5RMt5bVGHXuiZfwFnS7L/zaEwwUCaRSR1gAKCRAFnS7L/zaE w8FED/9S0v4o+f9rGc1s0XjtxWxXWXuNhwckzJpl54CVdCRP15Zt9niJgx99JnLVX1N+zdXNb2r bcQUImzoeX4vFqcEQmDElGa0VPK/jtIt692Iif0FFmMDx9gCqIQP6mQBUYAg5A2KRlHdJrCEBg/ jbA0PjfGTb44eHjdclModiPVQszACjKZ/ZXeLEt9tkRtbxMDw7ejcyi8cEb582U+DxuKTIOVfox J9A541EE3wpE2mKBEvafm6T9EGQPzPKPAnO3h38+47EokVn/GMgcDB954UlKsfB4e9P/8g/c/KP Hd61CiZku177YQDBAUPoTJyxh4k6YnSgrlbHP+m3Rd6vvx8q/T1jkX19j3tC75jJVcJyeU3sZGa 1J7xaTyvI50YiNZIcuzhIekT7k6h73SXyGHlr2nFXvrxHVMmfxIumWEsIAZjZfjB6tSpT5MB5ZN FeeVzl2+rKUM7sxp+Ar+gUGoeIzWaehG4UlbAhpCjNzHpjqeXXoHiZba+jpr4u8X/Qo7DmVUwhw Ja+LNPcgi2ikEL8fqramAAzy9xN87Ug6cX/EkhTCeJqmMMBaF01/U/Ig2piBAxtlXiEtmIRImIA qcOBn+9X6Iz611rrgSjwYrRQGCAOnAnvY0KNXrKWlSBudjWzAl4SlV+EzfCuQEvo9vxDTetF8Lq RSondTaSYnSH9qA== 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. Acked-by: Linus Walleij Signed-off-by: Bartosz Golaszewski Acked-by: Arnd Bergmann Acked-by: Bjorn Andersson --- 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.51.0 From nobody Wed Dec 17 12:14:28 2025 Received: from mail-wm1-f42.google.com (mail-wm1-f42.google.com [209.85.128.42]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 6145F33AD9B for ; Wed, 12 Nov 2025 13:55:54 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.128.42 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1762955756; cv=none; b=if8WlHqLtiN0EdXKYoNnztHKptUI3+pr2iTogYb8zoqEcTWWM4Dww3fWo8thTIfy7HQ6RQsegH2asr82IZART1trxbJXvKENdSR01mSx4hEVWh1Zdb4wPKBYWlH0ezC0UVT3zNW/XKe5TTlSlyKWYq1ybVMFfz1KY4m/1qDZEqw= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1762955756; c=relaxed/simple; bh=pMVIDl094hPPBJ3k0e5jfhRoS7U501FS2T88kBd7i0g=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=KmZlHXPFBo8RKLKfBbmCY0+YZPRv/T9+gRn0/rBcx4edCLKvmfuk1PSG9/jZwbUIHOGtEXKUA/ztKT1N5QU+m7jiirVXBJvZI8uEZsJq96tkuJhPXzOPt55gXM0DSHWxmAMoeoQ7UixIuCDkdICsVep+1yWbJAM0/+4/tUsi2Fg= 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=QS+2BMr8; arc=none smtp.client-ip=209.85.128.42 Authentication-Results: smtp.subspace.kernel.org; dmarc=none (p=none dis=none) header.from=bgdev.pl Authentication-Results: smtp.subspace.kernel.org; spf=none smtp.mailfrom=bgdev.pl Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=bgdev-pl.20230601.gappssmtp.com header.i=@bgdev-pl.20230601.gappssmtp.com header.b="QS+2BMr8" Received: by mail-wm1-f42.google.com with SMTP id 5b1f17b1804b1-477770019e4so9779595e9.3 for ; Wed, 12 Nov 2025 05:55:54 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=bgdev-pl.20230601.gappssmtp.com; s=20230601; t=1762955753; x=1763560553; 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=AqbaIc3KaZCmVuB7kqLuKLKtHplI0gVqS2YvAhrL6C0=; b=QS+2BMr8zwL0QqE6FRda7pLvxTD0XVkuKZ0vmbHn6+h8WNcTepnkta+ORme+Zk/36J 572lqLKqsGnX9siT+ht7pUbQv68fRanbdyWY0WLtL7cWYdDn/Vr7OoIo1Qg+MiVS0U0U H1d0lqVhku3BLFEzndUceItzk6x+lFn86p2SOMCfDbr0FdvND4SzmfQWxkBytcD8rwm+ KYH2GVGWbZ+2WWwwl9A9xKxpV3KnYg369MbItIm5NwAla7PoOtBSktf/JCWoWMajGZhn sL+/j/M0t2ehzE1P44uWaKNv+jN+xD681gSdqcUpGTZccBmWE/3nbDz/sWkJqGz7d4V3 kH+A== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1762955753; x=1763560553; h=cc:to:in-reply-to:references:message-id:content-transfer-encoding :mime-version:subject:date:from:x-gm-gg:x-gm-message-state:from:to :cc:subject:date:message-id:reply-to; bh=AqbaIc3KaZCmVuB7kqLuKLKtHplI0gVqS2YvAhrL6C0=; b=UXblBweXs8poVIfNIo+UORIG1ukk6mwwsiLefFgWM599bCUUcidlht/B9mzTweS2hr ae1B1z64E4K38ei+CZQJ7qJ6m/WeAdGfsShDAfzVyLwzI9rFO/h1SBAZKWAsV58LoJar Xfql2QnYvUMrZN3ZKSohz9BptKg8Na+XMFVy1w1tD53E6dMtzkkBhs/HZ1g90RkKIRHX m7AU35FavCNKxTqkfQi9f/VTxqfvVFoLqItbotdkECcKIL7dI94aqhHNLZH4hBYxXugp EBm4WsZah1Dvt6+O6QpfI+gjJ7LHotFU9sgyZEQ+SmsVL2F9JCYEdtLO+7kKVR+C4auB qhcw== X-Forwarded-Encrypted: i=1; AJvYcCVtofTIsr1TL3MhWmMFjX0fUUwJjV8r6Fh4p9921YyaCPmlgJAtsOw21yyhwvkR9qEIEce+4x69v2tnyLU=@vger.kernel.org X-Gm-Message-State: AOJu0YwcHsP8qr887iSxESC68E3v8hly1cEC07cVAqboCejAQ7aLpndu sJi0bDNybgezIgS6kIaK0Yf32zLUMIdUQJG2MrCS7GW/5kWp080oAfyMKPNH4ymorV8= X-Gm-Gg: ASbGncs56KtP+G5RHJke/C7g87R3XAu1/4eTTBIG3XzK+jM7Q0qvqZBHtMFxhFaxR/+ r2Kct04K9mzUhlcrSaTO7imw20dm4lHmc4byDpKt3f1HLLVhx3TeNcUTVNsROPUoOBi7gEqiIcY U7CfR/T5NJOCB3ql0KUmojzjjNmO6onCNwprEKGVFtQafjvGjkI8DakuP+hLda1jBBpazeWEA1k 939Oi4YLrQ0NEupLmBenV1DDB/FZNdIszGIoyHfWsUOhVLwwPRRDUTIn9uUXSL3+PZuDO+iY8/J QbNo5mmNiKBFOx2kqCACLW/nVbbY/LeEzs+FDDrIFVcNFUM3NStdOGA4wa1VFI5Ld2/6SDUibZH /OExHk8QEeWcNxVNkv6Md8+CqI/wUr/znn3i1E/D8Xh2sNU+LfaItta7Y/r8PtY0d8Mw= X-Google-Smtp-Source: AGHT+IHJt2UAXPW2MhXPVBBMI+uiCZQQH4pvDWU/Qe5FJx2daMpbRe2y7K/kRKjmxJ4TfWX+tRiFBQ== X-Received: by 2002:a05:600c:3511:b0:477:54cd:2021 with SMTP id 5b1f17b1804b1-47787041346mr31124405e9.8.1762955752566; Wed, 12 Nov 2025 05:55:52 -0800 (PST) Received: from [127.0.1.1] ([2a01:cb1d:dc:7e00:2a6:e453:42d3:11]) by smtp.gmail.com with ESMTPSA id 5b1f17b1804b1-47787e2b835sm37711685e9.2.2025.11.12.05.55.51 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 12 Nov 2025 05:55:51 -0800 (PST) From: Bartosz Golaszewski Date: Wed, 12 Nov 2025 14:55:37 +0100 Subject: [PATCH v4 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: <20251112-gpio-shared-v4-8-b51f97b1abd8@linaro.org> References: <20251112-gpio-shared-v4-0-b51f97b1abd8@linaro.org> In-Reply-To: <20251112-gpio-shared-v4-0-b51f97b1abd8@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 , Bjorn Andersson , Konrad Dybcio 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=1104; i=bartosz.golaszewski@linaro.org; h=from:subject:message-id; bh=5tWrLPzClpmnMADJpWcVY10mVN9q3Vw/ebyB+WPO3Cw=; b=owEBbQKS/ZANAwAKAQWdLsv/NoTDAcsmYgBpFJHXDZMnwTAKRmvdN9vLJzwjFFiSdS3OXohry PUdZAt0JWGJAjMEAAEKAB0WIQSR5RMt5bVGHXuiZfwFnS7L/zaEwwUCaRSR1wAKCRAFnS7L/zaE wzUMD/wJ3SBi0tLbJfLHaJhap/guD7pReEjnW/JOFDIC2yq5EzUDFEcY2ViZzm0g23lmQuNDYfK A9dkc1Mv+1lDHo2WyNnysll2axbhGj5aUrn/CRjyhAP38l+zWwE1lmSO8/4QorZVdOBbmKtqgs2 cAh4KcGjmE3UCT6hw+o1H2Y9P9CjXJR9elZ1tGxe/rhxV/4AZcVd9Y/ii8edu8RxZ/sRYhEk5WM fRMEOqLO2vvrStmWdHmJVvco93x2yBlOM8nGDFyAfbus7MnFkbt3/oM1bGOFNMdljTdqAnmqduW 9w2n4+muj0DODSDmbhf5LxohVoIe4YjL2osikP+z32QEPd+RH6u1WwW/yNKHWsCbGjxiZYp5ySw hukbppWtOdg7agAmIeium9gbFu92bYTi6faAUI6gElRB2ZpQxJX0w0K7vBLYk+yDV+KHtZwzdeA dYffKpRViRdgesoFBEq4ngvfCW2BXb6Igh6DGMUY7oMiWxZhzSVXJJoUq+3k3a3ly9r71Fd5t/D XwQRIape22DdjWtcBS0I+N3YZ551F3dIYO4wV89vQEqxGyIpGgKO8fTaDdg0vGfaz5fOGjHuyiT 4vcee5JPb+QUHuN3nlCYmBKHKr73jH+0N+HzpMRJZftovkFJRJqTD/ScNSWk0I/RgCE8u/APQA8 6yW1XuYbXdH+Qlw== 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 Acked-by: Linus Walleij Signed-off-by: Bartosz Golaszewski --- sound/soc/codecs/wsa881x.c | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/sound/soc/codecs/wsa881x.c b/sound/soc/codecs/wsa881x.c index 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.51.0 From nobody Wed Dec 17 12:14:28 2025 Received: from mail-wm1-f42.google.com (mail-wm1-f42.google.com [209.85.128.42]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 110CF33B96C for ; Wed, 12 Nov 2025 13:55:55 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.128.42 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1762955758; cv=none; b=Kpc+fD7lyX/NDDVT+MqKS1zyOT0mRjOiq4xpxz20m6GGZtb57N227zghbQxmyEGVD55RKOaa63q4s58ALBssGyNFqUfUjdHGk4ORfF7IEefQk7qiiM+4GMTgE6uviwJ45yKTBQhM7gF3zyT7akUT8hg0FDYHheIViaXDC5VthP0= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1762955758; c=relaxed/simple; bh=gq2GeWwtoAxhgReAyByCwNLWKfgCp2mKBgj6Rr+H1s0=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=hhaST3N8XiQu4UC2sq/0+XHo24qvBRO0yA4Ad6IX1i90oU2YeffOBZQu2b7QbEoNF1X2nIGBhhXU2w42iri31eP1t9PzMNoMUE5uKvXelQw5PmhgP6M9+0GAywa+XB6t8QgtQvRHuBe/ov49PudBZO7q+f6Nf1tAPBm6zD2XJsg= 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=EW2Ixc4B; arc=none smtp.client-ip=209.85.128.42 Authentication-Results: smtp.subspace.kernel.org; dmarc=none (p=none dis=none) header.from=bgdev.pl Authentication-Results: smtp.subspace.kernel.org; spf=none smtp.mailfrom=bgdev.pl Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=bgdev-pl.20230601.gappssmtp.com header.i=@bgdev-pl.20230601.gappssmtp.com header.b="EW2Ixc4B" Received: by mail-wm1-f42.google.com with SMTP id 5b1f17b1804b1-4777771ed1aso6322995e9.2 for ; Wed, 12 Nov 2025 05:55:55 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=bgdev-pl.20230601.gappssmtp.com; s=20230601; t=1762955754; x=1763560554; 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=Pibor61VRuWGPDBSUEX8Qfx5NaK+JEoulBZiwQw9G1A=; b=EW2Ixc4BwrTuFUmr336IYp/JLy1njBjVs/2gKeXYa/JjNNBYEIU/T6i4V6fNxTnFfV 1VrevNb2NbSx1gswcEDiGMYI6I51RZNSt0dJnvc/qSDSrgNI8pximJF7LgU5LMSZlNdv 9TUAiFvKKuq38EZ78AepQZnHpdrNIo9Ve/c1NDgeiRGV4VgbCwaPW/lpne3O/dCTArYW CRnPejwOVLhTWJvBOESt+hGoh54oXUhGXgfULUc3ByLiRQBIpbUpALpQ3PTlGqKOG/mP fzeqkQPv4HfTFBhHDes++lScXwKBkTtR9yZ74axbuyuDF8eLBfnG9q5RWvXn8aBf5xlo Hn/w== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1762955754; x=1763560554; h=cc:to:in-reply-to:references:message-id:content-transfer-encoding :mime-version:subject:date:from:x-gm-gg:x-gm-message-state:from:to :cc:subject:date:message-id:reply-to; bh=Pibor61VRuWGPDBSUEX8Qfx5NaK+JEoulBZiwQw9G1A=; b=doZdtZh61nIWJ5fTfsGuY25mSBauoNTpKDbZROpKG1MZIINbyMdG3Bp345vwZo4+o6 sKgSRFVxzCFnQ1hXFGwEvjtntHU5exhuNj58ObVN+Sm52fkInApPtW4Yv1ItR7mJf4AJ zxx8lUM7HC1bXF6uezhWIN0CWIsVEd1vEQbbKRypHA40vkVvboNpucIa2XJ5arGhslM9 9FjN2T4QcgDQNPVyFN1n6OW2tIYN4qt0q0Lh9HEtemH6VdNydzST7eWw8ChbABQJy2iB OCLR8ajlehe7aPfNCFpdz9LHgGQdysiE6hc1ZAuSeVg4y5FUXTjClbG0yUxDBEmVb7xK NjPA== X-Forwarded-Encrypted: i=1; AJvYcCV1pqu+MM3rmn1a9R4o6jlO1jzQT/ltB+py2NieyYzoKv08XD8miJSL58unZq67Cu9H2E6Wp7aRZf9uflI=@vger.kernel.org X-Gm-Message-State: AOJu0YyQ7FNnx+GsPN9vQKDa/DWsx37VbKBt85wX0BBDqg8M21UVXe+W fkXEeOft+rAD41izSDct5B4jovPm0WdS1RMdhQ4S9/JCVwRlfxzKr7b7CHuFyYUBht696jQSwA8 kxryVahg= X-Gm-Gg: ASbGnctC8k2+xlnFsngbutdqorn6UadGjyqyYHjHAFT7CKPmHYJW4phytqgp7Ph5A+f 0sV1RUJeyXSvvHaBedPJNiaA18+O8mBlqqxZ+eWlOc9yzA1EuSFOG8pD2ZGd2Zk6LkdgKOBGBl3 /0nI4VsKBqvHbNW/3TEPUefuSmdiLzjxtswvNxbv4Drr86a2ybUGNn/ta8TyvKJ4tSBiFRbbSyu iAXwN8Sa7oK/ArpuVlTOZySdHBJm2U13XsXJjkL7jBdSfWtvJ4JcKW1Opt02AsJVVsTMbby+ZlR popCcM/3VgRFqgTJ4y+8nPH/qoo3qS8Rka4OJ/Fn79opqGrKY5Ts6ub04FDKcEEc/7GlCzE/2Pi pyhcP6pHvJMagjp1JkZxtbIw/465EZiqvCWr0N9KkZSoOLTuo4w9O9MrMsB2RP3hLtqE= X-Google-Smtp-Source: AGHT+IEtvSDyr11LVdJoG53McXc+mzSebCMpeiLoCNayskXzc1xY0qsvnUscd2uSM6nTy0CesNazMg== X-Received: by 2002:a05:600c:4e8d:b0:477:7f4a:44b4 with SMTP id 5b1f17b1804b1-4778703cdaemr25638175e9.1.1762955754244; Wed, 12 Nov 2025 05:55:54 -0800 (PST) Received: from [127.0.1.1] ([2a01:cb1d:dc:7e00:2a6:e453:42d3:11]) by smtp.gmail.com with ESMTPSA id 5b1f17b1804b1-47787e2b835sm37711685e9.2.2025.11.12.05.55.52 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 12 Nov 2025 05:55:53 -0800 (PST) From: Bartosz Golaszewski Date: Wed, 12 Nov 2025 14:55:38 +0100 Subject: [PATCH v4 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: <20251112-gpio-shared-v4-9-b51f97b1abd8@linaro.org> References: <20251112-gpio-shared-v4-0-b51f97b1abd8@linaro.org> In-Reply-To: <20251112-gpio-shared-v4-0-b51f97b1abd8@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 , Bjorn Andersson , Konrad Dybcio 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=1337; i=bartosz.golaszewski@linaro.org; h=from:subject:message-id; bh=J7wcxqH1nXBAkgczyumTwaJPo/9guzjHl7eS3CVDzWM=; b=owEBbQKS/ZANAwAKAQWdLsv/NoTDAcsmYgBpFJHXOMadQXWhgF6RsrQC4lofPJXam1qmr5aWm Pv+ZdgkgLOJAjMEAAEKAB0WIQSR5RMt5bVGHXuiZfwFnS7L/zaEwwUCaRSR1wAKCRAFnS7L/zaE w9oND/9B2TQibJiQ94fYo4sg5Jc7PIXazrwBZOKxEffUtu865Wr3sHOIb73g/CPdrof6sPFX87v tJ0WbOpt1U5fnlUW9N7Ti8lheKmnC5fnqcb4NF/Jo6BLAQdt1VZb3rafkaYKEc2HwLY+cfjJiLn +qCNG0p8aDajzp9CfgiKwE8nR0GF1vo6Q4FOIQ3LHa5h0Bjg0QGN98IJYYBHLAVa9QSwra3jKWG TJgxLXTg8fIIvmheLbwstNvrAMB7f+0VqIWjSX0H7Ziv9BFtuW+hC9MrZO1u9jGdO/ch5l3/vaV LH2hcTM8yiAB3y3fQ+q6ilhh+PRLZNGMoGjCgthQyYi6gzW7/vs7m7iEazsevP/J//jUow58aq0 jWQrwo01pMpuPp9NCQeRFfhoSlZhG7ct01F90PFKzWgzOkMU7Iw6NXtMF4x/0cmowzP1biWGG2D lPJEu7u6BrWuM6gTF6qxoYeNaA5EMECi5SF1keLY2ETkdQskHBsVSknhAg3QUIepSbjIGghr2Zb zVzumI7YOFBI6YF/DpPETCLtQ054rpVXLhhcbTGieGU0a8CI3a7S3sgLeo17uaRW4GUbirB+w/G ZhTwfaA4DIN+3Zw30zSAWpFkLgJSiwRHA7DQOlip2dpFLaN8V/XeLyMhfsR9krtKjBdB8F+1fkU b7r1+CMpTEED/sg== 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 Acked-by: Linus Walleij Signed-off-by: Bartosz Golaszewski --- sound/soc/codecs/wsa883x.c | 7 ++----- 1 file changed, 2 insertions(+), 5 deletions(-) diff --git a/sound/soc/codecs/wsa883x.c b/sound/soc/codecs/wsa883x.c index 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.51.0 From nobody Wed Dec 17 12:14:28 2025 Received: from mail-wm1-f45.google.com (mail-wm1-f45.google.com [209.85.128.45]) (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 7B5CD33D6C2 for ; Wed, 12 Nov 2025 13:55:58 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.128.45 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1762955761; cv=none; b=R2RXCDOpWcIyCE0BMvz8VX0IMjZ8vWMRXSqoMJfHp0PwZQF7DQBD5PQ0RgRH/I9kSSYqStMQENSo8Kr8vX0VasJDKbVCck0J49xhwBEMNHZlGkcBfC8DflGeW6VV9JrcKI1uLxG425fd92jPCxSJxp+xfLjfGE7N/Ac43PjS7wc= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1762955761; c=relaxed/simple; bh=Ws7WZR2jJQBsUjKHfWRA1LnGQPkf3K7KRf54zRBU9aU=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=bdemLJXZ+zogUGnqQuqOVOcAkq70/A3OCiPmnH6cexMRLhhhbGjde4iXPLzgDfhKRli6bX5tIQVwbghqWwMRwYQK9nQk2Xa8/gExSsZrdyp14Ye3mdD3yp1TjciCjndqd+RjYg3RlwRk5Eyu8XvBDnUVu8uQMub9pcKiOE71GO8= 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=vtD1s5Rd; arc=none smtp.client-ip=209.85.128.45 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="vtD1s5Rd" Received: by mail-wm1-f45.google.com with SMTP id 5b1f17b1804b1-47728f914a4so5597565e9.1 for ; Wed, 12 Nov 2025 05:55:58 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=bgdev-pl.20230601.gappssmtp.com; s=20230601; t=1762955757; x=1763560557; 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=kp0FmiCJj71Jl4oZffl9a+Nd4P6twEmX35nVwvd5KFA=; b=vtD1s5RdxaI/rWrQIEp0qKscCVOtMbZEGAhFkriFxjO6Ie5U7cgtLb+Y0BSKmHlQRu 5huKbwDTk5dyOIjdEohzuL6NVCFdOiwXuuYw1AehKo8Oc2noy/92GXW5/bZRrdwzVatj tN4xFzYAFS+3fumCB5qR6FO4zTiTdjwBSjKU3QT9GzTyextCn/4AoDIMZJSn0ib3YMWI wgUt9decgidFF8k2LuvQkBrcb7pHpkdiYiRwxBrSyf/VTMVeey2GYmo1JOG11odZUrW0 O++/QKmEqsytsCcdRLPW3K2uKEHZCqTK6+S3KalLanUeljLwCab7BbBaUk87y9z+QBbl yxaQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1762955757; x=1763560557; h=cc:to:in-reply-to:references:message-id:content-transfer-encoding :mime-version:subject:date:from:x-gm-gg:x-gm-message-state:from:to :cc:subject:date:message-id:reply-to; bh=kp0FmiCJj71Jl4oZffl9a+Nd4P6twEmX35nVwvd5KFA=; b=YwLSXXRy1g9vAI2MGeGdws9tkH10qJZI+kRhfU+G/rt7d44ZKD0hA9rigdWBMcghmf LQ9qCfFfQrPAFZ0ievaxNfDjN/wDcIGcdZBHWd1cPUGoHujg1hwlcwbg2wU/B/IjatqV zeVR6O7vkEvrNZPtuSBl9eGlx326Cv9y9Rp+9mnNVFZns+JCRK0H+R6pR708eoEZD3pQ /OsvC8ThTG3tbAEqLbYwXR+/hQYXzg+QC83d2qjkl7BuRfEPfQb1vXnzQFfDck5+dzDJ 5Ys0XxP0R/UDcxSje96GyTF8oc5yuApj/tocwEyDr8Mcwbbo7xPZtrhE10kgFWbIcbBm ZcCA== X-Forwarded-Encrypted: i=1; AJvYcCXLcgECEyczumprwtoKdk7LqQyAjyYBxjNHndUU/EiOXiGiHvaOEhT1El9Haq79ct/LhCojTpX23K1YsVM=@vger.kernel.org X-Gm-Message-State: AOJu0YysQ08JX+6BjrDc3MwkH4hDJqVoMIuJQSqSFZ8tFUmZEdTk75Si JIVGRhgVmVNxovEMUBw57bJ42C+A2YpmwqR9LrojpBuDz+ZEprZp3NUqdFKZ4uSNoms= X-Gm-Gg: ASbGnctMvFYxT8kAFElGxtRpr7a4eyuucMxGvKvnA4FGtTpP4qQRMKg0kdS2880+hLP vuQovPg2jHn+MvYrf6HYEgKev0flzJIvTS0M5Ggi5pRB12ljBBCLBDUP3YX/ygEbRflRalALZVc 39Tbwfxg44YzpjeePK7V8+Zj/RUWluci4A9JBjtVidGEiXGcTu32xgl8CZqJqTZkEy0hpyoMCRo GI+xjHnjjt8Ba6V67PJJJHl7TdjpYSFqPLO+5y4V9mH0MDqGONSq9axg8VHY3p40jlQv5mt2FGN xPslTk1PaO8PPgdMojEQdNZxc4iQSJc5uSkVLuFvJ7NAE0/pT9tba8nmh65/Mz8yXwkCihLTiG1 D6Izmtd1DplYNzAF7T46KLBdwMNRKkM1lStgl8z2T3BLPwlw6AWwQ+Ay/Hi70uRETgdc= X-Google-Smtp-Source: AGHT+IG9voS48hdT+xBkoQt9DZv1hKYOn+kmcoFvvCmGnWxQyhCTGn6OKWMid0l6AgV8010JdBsVyg== X-Received: by 2002:a05:600c:1c0f:b0:46d:a04:50c6 with SMTP id 5b1f17b1804b1-477870c32a9mr35632365e9.30.1762955756833; Wed, 12 Nov 2025 05:55:56 -0800 (PST) Received: from [127.0.1.1] ([2a01:cb1d:dc:7e00:2a6:e453:42d3:11]) by smtp.gmail.com with ESMTPSA id 5b1f17b1804b1-47787e2b835sm37711685e9.2.2025.11.12.05.55.54 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 12 Nov 2025 05:55:55 -0800 (PST) From: Bartosz Golaszewski Date: Wed, 12 Nov 2025 14:55:39 +0100 Subject: [PATCH v4 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: <20251112-gpio-shared-v4-10-b51f97b1abd8@linaro.org> References: <20251112-gpio-shared-v4-0-b51f97b1abd8@linaro.org> In-Reply-To: <20251112-gpio-shared-v4-0-b51f97b1abd8@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 , Bjorn Andersson , Konrad Dybcio 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=1453; i=bartosz.golaszewski@linaro.org; h=from:subject:message-id; bh=cRJh4UNEG3HFtyWkN4hxt+/hsKQWJv1/Ds8BXH+v1q0=; b=owEBbQKS/ZANAwAKAQWdLsv/NoTDAcsmYgBpFJHYk7DEi8vVcJ8C6Jm2yEHPJBGM9iGwZrEld QRXIbLOz+iJAjMEAAEKAB0WIQSR5RMt5bVGHXuiZfwFnS7L/zaEwwUCaRSR2AAKCRAFnS7L/zaE w5z8D/0TLxRCfJwRygeJ86VvClZB7uM7J1J7NnDKtg4UUs56/PXpS0p9l9x6HrZCLCmXiKCXC6S rZimvHSWFvMB+C5AzBTweR/w8AU/dwfANLNHEFQo+iD3CLl9eCDO5S4D3mTH+GpDffO431DA2ra NV8XBbpp+4Bo/za49Zr9H2ob40gyv6LMnx0JdjauTBGDkdzOzFrNNOwnVCFn/teRwYxnFj/xFrN 4GP5pbDAURlG/xIMeu9nKdruuD3lEP3b6bQYe/eYqZeHosVGYr7NPr0onVW2wJHG/RzQefqOWOH ABURXDvkqFhKu+lb6wia8HbWw+RyjHT672anUmCEfXDZ9LM0nquoSFzeaiN7Jf6cK/jbKzPIlvC Ps2AYAZ1GqYqxYwpwn1rZnnBc0OrBt1a58lr5tBW0hKn/7yuvMJrkWbuXj0BttD3FNhif/16siA lttnkrbLgbYY0YjPKMPkbEjdJWESGR7zBrNDC2Va507fkTnxZ2Phqf/lxwNF2PfVO1PzwnBZoSc CmG3UEV6uBjSgz2CaPMSPEypNdH4WPIeC1t4kRTUWEWsGV4cHpnmh4BBtCS7l/clKFHd9kYjfhf ic0J3okXXIW6QgaD1f5jyr+g5oh5qRFfMovbUX6XdJOev5b4Rh8yx/EQPfOmlJUsw+FnPZDBf0p o27rB4fzdQATFGg== 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 Acked-by: Linus Walleij Signed-off-by: Bartosz Golaszewski --- drivers/regulator/core.c | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/drivers/regulator/core.c b/drivers/regulator/core.c index 2eab56df042e6b05abf0989f425dc161c7b0e66d..53b2b2d3746f9f2419234912d49= bd8b4f21a893d 100644 --- a/drivers/regulator/core.c +++ b/drivers/regulator/core.c @@ -2742,6 +2742,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"); @@ -2754,6 +2761,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.51.0