From nobody Sat Feb 7 23:48:06 2026 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 35208346E52 for ; Wed, 22 Oct 2025 13:11:00 +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=1761138663; cv=none; b=MelVDtm39ZmJFhBt9vgdkJhvwVwHJ+RVZalOS4hWzFJZcMcEvK08QMWzmz2HsZJrm2udcYBv4BD8qDsbUsqZmcNrdA3Fw4M8koN7sOJXavJt3SUNCq9ZJPQQOdC68bWse2GOQlTMAJB1HJPKlutDcYhX9AiThFymqCizVVT7duI= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1761138663; c=relaxed/simple; bh=BLrlpEi+Tf0y57g8++fj5PBGfPPtXYf9LwcXnw/5/Xc=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=boYiXZURz6UP+YBhpgXJcVgxvqm5dOk8VsOCdLOBaAMM1euED5OsYUpIRzOXEY3Pf6zu/39LZ8pyeYScMf9mqxIlUl4zdUehst+QtKSH76UMHNL2Nt0v+Ah8IdK2B04fsL+73+kx3A3IYffuPwDpHlP2J7tuRZatccqZEBNdlqU= 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=z+fZpotz; 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="z+fZpotz" Received: by mail-wm1-f43.google.com with SMTP id 5b1f17b1804b1-4711f3c386eso35805745e9.0 for ; Wed, 22 Oct 2025 06:11:00 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=bgdev-pl.20230601.gappssmtp.com; s=20230601; t=1761138659; x=1761743459; darn=vger.kernel.org; h=cc:to:in-reply-to:references:message-id:content-transfer-encoding :mime-version:subject:date:from:from:to:cc:subject:date:message-id :reply-to; bh=kUL6O2x/NPPlAHvfQ/3YG+cqGSjBZP8VuHP9QkP07I8=; b=z+fZpotzMA1bNc01WwXOuSIuv9Ohb/dnjX9TBI/ENZnyR5wwVRzbGLdoYu+gyfgdEQ NHda8i3XNmV32HjywBBuThjkQrv+kzKIfwU6y9fxqBZdejP3GGsyGUlkavt9ZLimZZ9L 9ZhYNcgpEiOWwZOQIOKS+wFLEI407gP9pdgDTs+ifAOycL3Ut1//CYqJi5DxEc1apzzk btUxfffc1CRskL2pb/Z56Iu/+DCtWB5wvwPtAMVbcFpj41rv0dJlOLa8dsG9f5uFQAe0 ijAdjSdlnqzhDx5BbwJukV7uzW52mQVpB4WvPMFFOwQsaUfNJbgsOqsSs3OBbN2xfPjG /fHA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1761138659; x=1761743459; h=cc:to:in-reply-to:references:message-id:content-transfer-encoding :mime-version:subject:date:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=kUL6O2x/NPPlAHvfQ/3YG+cqGSjBZP8VuHP9QkP07I8=; b=qiFIVL17535AyjzsWzEDTtamsaMc3KgmbKmzrqHStd/CAVINBlbzI6XCO6fpDa0U+j 2ReQM1OeDWytJQKeT+NavXFtbi4EiGkn4r79JZ54IscI4aScxazNN2lLXEd9++J/lv+v k2KyHguezCfYFRgugB+MZsO2yU7U9rMyxrPGDqrR4G/OtOB/ZrO3pWYK1IQ4WYDwpvAL E9hHWUlbRlyXIHj1Tm3AWBI1nYc2YNa+FyKYxYTU8UQ6vyS8lwyRlGBtBjcH7vxO1Kky 4z2FzbFpBTvfXFXBylKd4JacT9JijeNZT9UZ8Bog0Xm7lenoZxIjB6xbrtrgdVJdqwMU X07A== X-Forwarded-Encrypted: i=1; AJvYcCXu9U+EokNZ7G32i3ysgO2nkXc+oujJ8ytW9EtjpntMyhG52Fp6CMUfvHODZFTQAxvYHqzDn/fUmj63rfU=@vger.kernel.org X-Gm-Message-State: AOJu0YyErbE7J/UqyrY2cFYVUZ+c3DrU6t2zScg7YMAEwkpByObLluYe /1wmsnE4CyGp7rZtNlgL95pAoiucbwdv3b4p2/8OWUJSf+BgjC1eDYo59cJRxScDV8w= X-Gm-Gg: ASbGncsXUSE7lKRvqpdFhh8FQT2PCp1WuBb1YXyaabJGnpTAfyTK7u2KxezqosOJK6g SY+m7kmxbzR9ataj3OO8LOu6UZndzrSdyFXSVP8KgSEozPFGSkKJ8KZpXX7J+I80ej5ujFPZ7+a sy5qT1lxhRAzMMGJpOKkAN3Wrz0xtdhO4RcFiW4fa6fZ1wdbSFICMqSgCDSh2O6zTWKyzbklBuG 2mlUbAISFmXDbbcWiY0zXuNbJfviWxfzxyJntFFvrqfiu3DAolRr1aDFAhpR1Y9qY5j4+mtEBTB oZ3D4AvhcpfFkc6OurqQULE2HVPkIZ3p/eOBt8RDipOJIbZAuCoKP/EQw1BHuGfo2V0iV6XImtY PVtl/1iCY59tj/PalMkOiKwLQ07XdhaYRr1BdTtY7l+o304EcmHotJlyYRpOQguubDY5YyyA= X-Google-Smtp-Source: AGHT+IHy0lW8aRLBPmXRjIDPC8mTab5QUgEvOgdYolOwgCBdc19L3kJXN3yUq0gQwRUG/jyV9vZrlQ== X-Received: by 2002:a05:600c:1d9b:b0:465:a51d:d4 with SMTP id 5b1f17b1804b1-471178784c2mr170409895e9.6.1761138658987; Wed, 22 Oct 2025 06:10:58 -0700 (PDT) Received: from [127.0.1.1] ([2a01:cb1d:dc:7e00:69df:73af:f16a:eada]) by smtp.gmail.com with ESMTPSA id 5b1f17b1804b1-47496afd459sm38839905e9.1.2025.10.22.06.10.56 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 22 Oct 2025 06:10:57 -0700 (PDT) From: Bartosz Golaszewski Date: Wed, 22 Oct 2025 15:10:40 +0200 Subject: [PATCH v2 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: <20251022-gpio-shared-v2-1-d34aa1fbdf06@linaro.org> References: <20251022-gpio-shared-v2-0-d34aa1fbdf06@linaro.org> In-Reply-To: <20251022-gpio-shared-v2-0-d34aa1fbdf06@linaro.org> To: Kees Cook , Mika Westerberg , Dmitry Torokhov , Andrew Morton , Linus Walleij , Manivannan Sadhasivam , Rob Herring , Krzysztof Kozlowski , Conor Dooley , Saravana Kannan , Greg Kroah-Hartman , Andy Shevchenko , Bartosz Golaszewski , Catalin Marinas , Will Deacon , Srinivas Kandagatla , Liam Girdwood , Mark Brown , Jaroslav Kysela , Takashi Iwai Cc: linux-hardening@vger.kernel.org, linux-kernel@vger.kernel.org, linux-gpio@vger.kernel.org, linux-arm-kernel@lists.infradead.org, linux-sound@vger.kernel.org, linux-arm-msm@vger.kernel.org, Bartosz Golaszewski X-Mailer: b4 0.14.2 X-Developer-Signature: v=1; a=openpgp-sha256; l=2913; i=bartosz.golaszewski@linaro.org; h=from:subject:message-id; bh=rk7LOdXp57F1p1eS/LT1Bp//+s+MccpAywVrjh9Sj2I=; b=owEBbQKS/ZANAwAKARGnLqAUcddyAcsmYgBo+NfcwDJbBkx5ucXuoY0STS0Fcr8BiHjfoYGjt abNEB3nZjyJAjMEAAEKAB0WIQQWnetsC8PEYBPSx58Rpy6gFHHXcgUCaPjX3AAKCRARpy6gFHHX chePEAClv9rma9/Zj1+Dd1V5rBFn5At75Q+ldrHq3TX5K3fNqcCjqaoImr/yOEEQjFrLDUYeLnj NGBGbLb/pTLbHgU/ArVoFpORHOVW8hDXMUFIvZISHEdDrxd40KdxpNu+i0PGUjd476H5Bqu8mfJ x7v/yITPxj1qGDRIwPrBsrs1wJki3I9fEN6p71RnqG1nVcj1NTBxCw4WZ8RWakrJfwYF6As21LO o5jULMKY+FjNI/cmniaePf+8TtDVoxhVRh00CaOD5piXun7mZT+AhqUKJLM2j2UNM5/MPjn++Me 4kvIppPGLUUrlTim16CxEYB5yFpGSz577krytdShCv8ewIxfIF6zxo9gs2owtKfB6nFzXY19xfd /01Hmy4DkiEyOTULKBFebihOzNF0MQW3sH30dwVCkhulfrRaUBA5m94LPUs8bldT/i+0d7k1sxn Kknrw7UqiNO2OTSVubi05FaW/epIRiv8tXhzgALAVFKbBqHlWB4rEZkc23v+jZ9kBerQyXYQ8k6 lFDvk7iO/DjhBFatKLbzCxpzP40saFcoPL8Y3QSRg6CRQ+tqWhYHSNmBuX1zFQfHONHq/kEY0zM 5e2oMXpXVh/P5XVP5ukSCP48w3PLStmha+wgX0TtjxAjF4uIxm/5T4mRRJNrrulH0JTbIawq+1J pXHRdgnjg0JegnA== X-Developer-Key: i=bartosz.golaszewski@linaro.org; a=openpgp; fpr=169DEB6C0BC3C46013D2C79F11A72EA01471D772 From: Bartosz Golaszewski Implement a function for checking if a string ends with a different string and add its kunit test cases. Signed-off-by: Bartosz Golaszewski --- include/linux/string.h | 2 ++ lib/string.c | 19 +++++++++++++++++++ lib/tests/string_kunit.c | 13 +++++++++++++ 3 files changed, 34 insertions(+) diff --git a/include/linux/string.h b/include/linux/string.h index fdd3442c6bcbd786e177b6e87358e1065a0ffafc..16149404fc3aed535c094b9550f= 7bd7c9b44a0c9 100644 --- a/include/linux/string.h +++ b/include/linux/string.h @@ -562,4 +562,6 @@ static inline bool strstarts(const char *str, const cha= r *prefix) return strncmp(str, prefix, strlen(prefix)) =3D=3D 0; } =20 +bool strends(const char *str, const char *suffix); + #endif /* _LINUX_STRING_H_ */ diff --git a/lib/string.c b/lib/string.c index b632c71df1a5061256f556c40a30587cf45dce18..ac18313d9c52b38132f0bfdd952= cdec6b1354d76 100644 --- a/lib/string.c +++ b/lib/string.c @@ -880,3 +880,22 @@ void *memchr_inv(const void *start, int c, size_t byte= s) return check_bytes8(start, value, bytes % 8); } EXPORT_SYMBOL(memchr_inv); + +/** + * strends - Check if a string ends with another string. + * @str - NULL-terminated string to check against @suffix + * @suffix - NULL-terminated string defining the suffix to look for in @str + * + * Returns: + * True if @str ends with @suffix. False in all other cases. + */ +bool strends(const char *str, const char *suffix) +{ + unsigned int str_len =3D strlen(str), suffix_len =3D strlen(suffix); + + if (str_len < suffix_len) + return false; + + return !(strcmp(str + str_len - suffix_len, suffix)); +} +EXPORT_SYMBOL(strends); diff --git a/lib/tests/string_kunit.c b/lib/tests/string_kunit.c index 0ed7448a26d3aa0fe9e2a6a894d4c49c2c0b86e0..f9a8e557ba7734c9848d58ff986= 407d8000f52ee 100644 --- a/lib/tests/string_kunit.c +++ b/lib/tests/string_kunit.c @@ -602,6 +602,18 @@ static void string_test_memtostr(struct kunit *test) KUNIT_EXPECT_EQ(test, dest[7], '\0'); } =20 +static void string_test_strends(struct kunit *test) +{ + KUNIT_EXPECT_TRUE(test, strends("foo-bar", "bar")); + KUNIT_EXPECT_TRUE(test, strends("foo-bar", "-bar")); + KUNIT_EXPECT_TRUE(test, strends("foobar", "foobar")); + KUNIT_EXPECT_TRUE(test, strends("foobar", "")); + KUNIT_EXPECT_FALSE(test, strends("bar", "foobar")); + KUNIT_EXPECT_FALSE(test, strends("", "foo")); + KUNIT_EXPECT_FALSE(test, strends("foobar", "ba")); + KUNIT_EXPECT_TRUE(test, strends("", "")); +} + static struct kunit_case string_test_cases[] =3D { KUNIT_CASE(string_test_memset16), KUNIT_CASE(string_test_memset32), @@ -623,6 +635,7 @@ static struct kunit_case string_test_cases[] =3D { KUNIT_CASE(string_test_strlcat), KUNIT_CASE(string_test_strtomem), KUNIT_CASE(string_test_memtostr), + KUNIT_CASE(string_test_strends), {} }; =20 --=20 2.48.1 From nobody Sat Feb 7 23:48:06 2026 Received: from mail-wm1-f49.google.com (mail-wm1-f49.google.com [209.85.128.49]) (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 78FBE347FDB for ; Wed, 22 Oct 2025 13:11:04 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.128.49 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1761138668; cv=none; b=D7NMZ+SeeGzjL/YJJc/BLbn5/sTMplfxJPN9Pzkc7vw+cWc+Bvjvmj1gluJ5KGc1Tf9zJa6JrrXQvWUgASPhOiQBUYqd6ItUTLNhG23pJrAm/0Zg8PS8w7exmYwDjk7+1Iozh39fTSVuTvkv3P2uWyo3KiH8h30rs95Nx4KiMGY= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1761138668; c=relaxed/simple; bh=e64n37I4xAvaAkGyJ6yY89r2f0ctBq3OuH/O0o56ZxY=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=kF6wezJTZj4K3xGfCNOdtPLnSy4/E4tBNuFaDfb3WaAvbonJIGAnDuLs/3Xabhr6BZBQr5//fWR6LG1gsNSnBD83FZ+oME2qjJvdh+kH6pnYTviSO19Y8f6Gl3y+aNEWkHFAQ3lO3v1VY6jyQbmfthmhl3ML6IE+pjCV7AUTsOk= 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=ySmwzMN8; arc=none smtp.client-ip=209.85.128.49 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="ySmwzMN8" Received: by mail-wm1-f49.google.com with SMTP id 5b1f17b1804b1-46fcf9f63b6so38542135e9.2 for ; Wed, 22 Oct 2025 06:11:04 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=bgdev-pl.20230601.gappssmtp.com; s=20230601; t=1761138663; x=1761743463; 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=sLUcw2OFBeNQGOHQeLxgckCo4wtobuiOcK0Z/3Mk7WU=; b=ySmwzMN8sE7MA3qlB41arOaDdSti2Zpag8oMvpiHTDuUyDyXbgPT1pYOqZM/n53x5i ShV4/iiETV+j5McTxnm8jKWww4/kyu21LvAYfFohExpnfqrBZsqLFaP3ItSo6LvB9+iD iB8IvHX9XNGak9MJE77CQXitilThQAprnEO4SwgqJvg5zzvFO6nNvHORE+nBa/59S3mZ gh37r8cf5oAwnxYVQBdDm0uVpHeI5AZ816aEjiUq1oO/Z+fAk4QFbd6afuCAwWZOP4QV It5Kz3+N/SJkw+lD25js+CuUTeq9ijEFf8cyyc71MCHya11skAC+DHJDLn04ddrcbV/p nW/Q== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1761138663; x=1761743463; h=cc:to:in-reply-to:references:message-id:content-transfer-encoding :mime-version:subject:date:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=sLUcw2OFBeNQGOHQeLxgckCo4wtobuiOcK0Z/3Mk7WU=; b=QLwfkR+vzT671neIY2zXnMwXKRK6zt2etXcgRviX76JE92OrxvmIw8TP0+Al1RbXJB h+vkO9CFSLNLUuSppWtqwdF4v5C26P7JN3IUVI38/ASN8XExhRDQe4WaGXCLQl8TrXi0 ibi/yFOAO+jaPUzf/q1Q7TCXgvtmwqsxqgpm5etV15D0lEwSmz7eq5JEvftAr+CbFXF0 hOWn4Zy2/j2LGD1tA5Xyli/3FDP6sWiGpKzdfG9M3CH0VWi/NK5pW8MwyyQYhKJh4Tu3 r+ySYPk+JBY8sWcacSc5bQ3rcLl6lYIRNF32j3H0VnWocCHzbWnOLIidISoKnxf0wDCi cMEQ== X-Forwarded-Encrypted: i=1; AJvYcCUU++GzihCwda/RIBqS3JTOW/Z1jUz8P5d7jcIANmNYFKp2ir/Djq9y5vuffroGYq/9+TO/sXP5vupFtHs=@vger.kernel.org X-Gm-Message-State: AOJu0YzK+w17Wwdibqu8l+xlc9FeLbo3Tg/YExHFtOXR5n/tL1XpbEmJ 3/zoM6VWAUGz1Pc+F8Z698cKb2cIsaqd7HV/b5gKBvA/sX4mooVpaRaqGxB9ImA1dKo= X-Gm-Gg: ASbGncutJOjfyvrBFshHpKggaKchYUM9A49h6384nRAGk8RqJ+sqgVajflRchfdMjvN qnuXO7XsfA/e9aCAQkAiOGJYTvl0WnuaIylLO8ctVMKayYUJ7P+OhW8cYCpiKArp2Tk5GQLA5I+ 6c3+p9JozN8F4G8i+56y4kKkxNzA1KV/8NV8lTXPtxzT+9rm2Ob5pbXs0A+AqX2CaL3Wb73a4q9 WL32SuCVAIgVigAWrdmhnuhX2RmRxmdYhrBG4L794I20tFSc09eodA2Wjfuw0cQQCcX0hFcAsjO q+IO4P3YRebflyveqqwEidGJAWFo1r90NZEmW+rRenz76fRXw9FLDiZ+MleJ0lf+/r7VPUUtU9S SOUM38yJffUvsscqjE42n78OfBfzfwJNNBXA/phpBi5hi7Cyv++c6wPWCLUGD/SoPlHV+v5O2Nt Oav3pv1w== X-Google-Smtp-Source: AGHT+IF2yoMxKRceyJY5g7EYD06lQq4MGEUKhu1hgrBk0d1+Vdu+vYEezPyJjW99uVj5oDoAk/M1OA== X-Received: by 2002:a05:600c:4448:b0:45d:e28c:875a with SMTP id 5b1f17b1804b1-47117912b0dmr153800955e9.31.1761138661004; Wed, 22 Oct 2025 06:11:01 -0700 (PDT) Received: from [127.0.1.1] ([2a01:cb1d:dc:7e00:69df:73af:f16a:eada]) by smtp.gmail.com with ESMTPSA id 5b1f17b1804b1-47496afd459sm38839905e9.1.2025.10.22.06.10.59 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 22 Oct 2025 06:11:00 -0700 (PDT) From: Bartosz Golaszewski Date: Wed, 22 Oct 2025 15:10:41 +0200 Subject: [PATCH v2 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: <20251022-gpio-shared-v2-2-d34aa1fbdf06@linaro.org> References: <20251022-gpio-shared-v2-0-d34aa1fbdf06@linaro.org> In-Reply-To: <20251022-gpio-shared-v2-0-d34aa1fbdf06@linaro.org> To: Kees Cook , Mika Westerberg , Dmitry Torokhov , Andrew Morton , Linus Walleij , Manivannan Sadhasivam , Rob Herring , Krzysztof Kozlowski , Conor Dooley , Saravana Kannan , Greg Kroah-Hartman , Andy Shevchenko , Bartosz Golaszewski , Catalin Marinas , Will Deacon , Srinivas Kandagatla , Liam Girdwood , Mark Brown , Jaroslav Kysela , Takashi Iwai Cc: linux-hardening@vger.kernel.org, linux-kernel@vger.kernel.org, linux-gpio@vger.kernel.org, linux-arm-kernel@lists.infradead.org, linux-sound@vger.kernel.org, linux-arm-msm@vger.kernel.org, Bartosz Golaszewski X-Mailer: b4 0.14.2 X-Developer-Signature: v=1; a=openpgp-sha256; l=1034; i=bartosz.golaszewski@linaro.org; h=from:subject:message-id; bh=cX89PpdM44a3eQ0k9H2mF6X//0m35VFWgOWbVIYFNfM=; b=owEBbQKS/ZANAwAKARGnLqAUcddyAcsmYgBo+NfcfcpMLzR96W7BN60H4x3MK6Q+puGFD9uIE wmMWYL6QtmJAjMEAAEKAB0WIQQWnetsC8PEYBPSx58Rpy6gFHHXcgUCaPjX3AAKCRARpy6gFHHX cv4hEADgQsk4SDqsQQ4g2XVBZsPrB5rQs2uMZN0YJS0NTCuXM0VRt8+hcPaZqBiwgJ/aqaj0piN /NSpg+kXgqg7ZrB+r4iMLM7BwWFCk0uRXWTDqnvnr6IYOjiOk8tmrng05Pycm9LuHYzNxCIuzkl yLT3Ixm2/TxEY8e91EQRqZwxggaGKdwvENXSdcCJwXiWIGaCKaTa/HIDkkJHitBi3wU9hmRy79H MU69QTGVIu5qvdMUJO8L3eUwgzxZ4poU34/hJOvi7I4ivBvnCT7fcZqWIIMsXMe26WS+kZMfd6p Hc44SjrXUUje/Ntlxl0u+T1U7PFLaHoElR5h1t4Uv+7VyrTaGyhPxWZV2x7h687RKI50sv5V4Hf a/KahzwR8wvuwT84wDya3UTX/Dn4PCcNnJlN7BKCE58QJ8eVvUybGhEEUd/pEKIxcD3sFCcWt1r IRWNJ5Lmx8FQjzDGtu3Yl7DKVYXhfAJsC+59NnbGprw+ZLrVIMNpjhjyPZ7otpfrcDQxf6XJ35X wMPLgFrbkb3z9gmBRGl6ug6KGXgsc0Q10xXksnOMpMYWy30rL41Z0pa4GZ48zVmtHszl1luX9dG xdrId88bhFySFAMazRmpG3q2PafzOnaTN3PdOT8C9kL39JU6486eE3+eqtF8nP7jMkGWfAhYYsX KQaaOpV+fZHnThg== X-Developer-Key: i=bartosz.golaszewski@linaro.org; a=openpgp; fpr=169DEB6C0BC3C46013D2C79F11A72EA01471D772 From: Bartosz Golaszewski Define a new GPIO descriptor flag for marking pins that are shared by multiple consumer. This flag will be used in several places so we need to do it in advance and separately from other changes. Signed-off-by: Bartosz Golaszewski --- drivers/gpio/gpiolib.h | 1 + 1 file changed, 1 insertion(+) diff --git a/drivers/gpio/gpiolib.h b/drivers/gpio/gpiolib.h index b4c5369f8a3314244424d0c90ba006f7568b314e..ae9aa145ca055c08dad55a53756= 7a27de57f7066 100644 --- a/drivers/gpio/gpiolib.h +++ b/drivers/gpio/gpiolib.h @@ -204,6 +204,7 @@ struct gpio_desc { #define GPIOD_FLAG_EDGE_FALLING 17 /* GPIO CDEV detects falling edge even= ts */ #define GPIOD_FLAG_EVENT_CLOCK_REALTIME 18 /* GPIO CDEV reports REALTIME t= imestamps in events */ #define GPIOD_FLAG_EVENT_CLOCK_HTE 19 /* GPIO CDEV reports hardware timest= amps in events */ +#define GPIOD_FLAG_SHARED 20 /* GPIO is shared by multiple consumers */ =20 /* Connection label */ struct gpio_desc_label __rcu *label; --=20 2.48.1 From nobody Sat Feb 7 23:48:06 2026 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 BB70334845C for ; Wed, 22 Oct 2025 13:11:06 +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=1761138669; cv=none; b=dIM7NR34RD+TxcIMznADvFFHcYNW7/qePQ9jNNVW6VdmQG4XnKrlAxCU2rImbNWfHMq/Y4IyIstqp0l32lJJwjpFnYkY8QRVct5P1GXoxXkyrbH6jYg76/9uIzmA4VYBcoRLEETzSJsyWhEqE8EykFgkFGX0msYmN774V1S1sIg= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1761138669; c=relaxed/simple; bh=U+v8rHFdpElBX+FsUua3A0fwfFkZzlCaNmxO+JH8iSc=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=Fza5OPvwLP2adDoE8SEDNjjl58PzuT0u2Tzk59GZBK1muaX5FIui0UjUPTDpOKSm86jHCjGXbNf5WP/FK3KUE2Lh0aayoEUWsnoxLKkBtJwtAiGI703JyrrN/08OZMp6WxpkzuOBRtWcgV6UkAn/0bfKpN2DnzltwL6F5g403ig= 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=AWnORM18; 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="AWnORM18" Received: by mail-wm1-f42.google.com with SMTP id 5b1f17b1804b1-470ffbf2150so5897825e9.1 for ; Wed, 22 Oct 2025 06:11:06 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=bgdev-pl.20230601.gappssmtp.com; s=20230601; t=1761138665; x=1761743465; 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=yS98cTTrltSx4xeBUzNedH9UHkLLMppps/rwiTN9nqw=; b=AWnORM188UlRHUMlN06qcnogPH5JHViIwN8sdK1EmiuADcQrhoFWhHUnTMUTbtchY8 6nAekO3IsviEYw/BC8GeSlHBHbrmoQgXFiySnpVDWJNJCYh23Wi8IMFXQ3hEzC4cNrz3 isiXkBdjf1m0sKniu+BmmZUZ+pilrX+Fl1gKjvp41dnHJAZhYadBsVB7ZX+qJUdrAzjx u3AxBUb+f++TPCkz8uf49ZfXOFDrNbxk4kSFm+pZxdi9xehwbTv/DJSSq249+a8xRJq/ r7YAWZOt5zaaTGpXxZE9M1UORUwYaEj56vvPDF3pEC66lsGD+iSktd1oInLBm07hr6Uv GXjA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1761138665; x=1761743465; h=cc:to:in-reply-to:references:message-id:content-transfer-encoding :mime-version:subject:date:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=yS98cTTrltSx4xeBUzNedH9UHkLLMppps/rwiTN9nqw=; b=CAP5UPuG8j++tsmGSorFlTVGa8MIF/jovoa+p2n9J0Jg9u3ekl1Ad2uuCOZRBoarlG ONCfuOL9sjBPM9bUDxuLlcfbzt6tk9E6V31ZyxuyGpkXNRtrfSANsHFqAelGnbDHqnBw BYb0uGNU+T/mxLX1ghrZpL9BwcR/PTUUzIPXHOTD5mvslG1LAGstryP3y7OBcG1kbF/W UMjYrNXsaow2pKoRzL2qipmXoIrrc+g3SmafvdP5v2h74pUoN148hWUfQANthgh/5+Im 43v9SR0zCQxJtEHVXgHeYwAieTMDx3mp9i6Uk9o7EzdyxylloOAsmS1oQ4CVnH531TUn Q+zw== X-Forwarded-Encrypted: i=1; AJvYcCXSvwGgxDYkAxR6fKoR//LuTqAOrRqc1RtCEXtVSbTJ+d25IKu7qOdlHjw3/JVCqiiFKSvJRVJLh/AHv/Y=@vger.kernel.org X-Gm-Message-State: AOJu0YzxObWOpTDP5yw8OeFRDcYsWNutJQHbV1BTf8EVnHiTBbZDNXd1 TBIbeXnoIQy8u1AU2ES9dGZol/JfAtfqFTFEuDTK9NZ7688y5d+3KruvIXs3AkLnUH8= X-Gm-Gg: ASbGncvxRddquq40eDl5yLuNsQV4R+gEwgYmRZSVWqO4QvQkFLLyDW1BveUP8UOMqzw eFWTVP5wuLm5EI7KUbEg52fCC76tNuk+WEqWzmoqkPqkQD9slK3zQ1HUlVNwQG4JGXxaDOrCvVd Pk+asPbUwoPoeRr8P9/lJXu4SdY+qD6zkDY+fyzNE9Z8REFPyV9r1y1HjezYZAqJIVMsS4h9jJp EVsvGTnCtQHQojE0bNqITRJTk82dFhNYWBJQKEdzBxXK1sv9N2JFJLpcPjeCaXwl3C/1TGPdQ5N pv66JAG5Feuz3Yh40mT1bOs9cQpjWK5YlWUan6q2tfKLBdo/h2kek2GbIt/juoc4cz9VVgR/3eG l5Js8QfN6KGOk5V7PbiuhO5G7tJh9bo4uiQTBDGYyX/IiiivxGd2PsSbSja4KXR9kt8h0yTA= X-Google-Smtp-Source: AGHT+IHJKMgjdXmEICa9FW8jE7a3dMwnSy9oZ8XuxS/+CLTwvv+lfyO/RjCxmhSYVJxOnr+0xKYENw== X-Received: by 2002:a05:600c:55d6:b0:46f:b42e:e362 with SMTP id 5b1f17b1804b1-475c6f7076cmr9796545e9.19.1761138664904; Wed, 22 Oct 2025 06:11:04 -0700 (PDT) Received: from [127.0.1.1] ([2a01:cb1d:dc:7e00:69df:73af:f16a:eada]) by smtp.gmail.com with ESMTPSA id 5b1f17b1804b1-47496afd459sm38839905e9.1.2025.10.22.06.11.02 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 22 Oct 2025 06:11:03 -0700 (PDT) From: Bartosz Golaszewski Date: Wed, 22 Oct 2025 15:10:42 +0200 Subject: [PATCH v2 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: <20251022-gpio-shared-v2-3-d34aa1fbdf06@linaro.org> References: <20251022-gpio-shared-v2-0-d34aa1fbdf06@linaro.org> In-Reply-To: <20251022-gpio-shared-v2-0-d34aa1fbdf06@linaro.org> To: Kees Cook , Mika Westerberg , Dmitry Torokhov , Andrew Morton , Linus Walleij , Manivannan Sadhasivam , Rob Herring , Krzysztof Kozlowski , Conor Dooley , Saravana Kannan , Greg Kroah-Hartman , Andy Shevchenko , Bartosz Golaszewski , Catalin Marinas , Will Deacon , Srinivas Kandagatla , Liam Girdwood , Mark Brown , Jaroslav Kysela , Takashi Iwai Cc: linux-hardening@vger.kernel.org, linux-kernel@vger.kernel.org, linux-gpio@vger.kernel.org, linux-arm-kernel@lists.infradead.org, linux-sound@vger.kernel.org, linux-arm-msm@vger.kernel.org, Bartosz Golaszewski X-Mailer: b4 0.14.2 X-Developer-Signature: v=1; a=openpgp-sha256; l=18315; i=bartosz.golaszewski@linaro.org; h=from:subject:message-id; bh=miECWIP/1gqHMCXzhWhe14uF2CJsdYWMJpRYtwx+SRs=; b=owEBbQKS/ZANAwAKARGnLqAUcddyAcsmYgBo+NfdAvowADLFNPkidna6nLbNkf2EaeNe3+cFz l/7fbdVeWqJAjMEAAEKAB0WIQQWnetsC8PEYBPSx58Rpy6gFHHXcgUCaPjX3QAKCRARpy6gFHHX chzzD/9hjtZx0RBd2PIKEfMDQNKwtdmyvS5gfg9+ViyDv7gSSam3ZIlT0xMAeJnNpcfvrLd22Gy E/csnJldgxSYCbIic+bH4KX8i4gdm8G1XG9nR8NjoXJ38c+wwyNOrTqzOXheaoQMLrxnO4Czzhn UCV9xGIRSbxVu6JOhbr84btBOF3boLd+4UKKVbfZqDb8bKoyWAnRIydOgHGnPnyQF/BIBK8GFp1 h8i7rh25AkmHagVk8zd1unihZSrsGVF/BjDFJppMp7f1KoC16Wddzp4z3jrDNmrZEf+q0kXJhcy hL/zv5ANuNjGFajWVeK9QvlWcrZ1+vEAns9DP6ZXq/1ES+jLm1oQGX779Bx6IpCLq9ehgX/SORy 64ekFtbR38ZvERcDWMEomFViZAVJxCP2XF+0iJVK99ExX8jYUkt00M2hUqRSt06WBinQDX7eAfO JfdQnXeSWJE5zEAA9779WH5dXwM8ifb448j0FrH/we8oCDbu3/3SMjD37gL7tQ0pdFQNMSZaFPF m45u+ZHqKG9lztZ2FqIOpPNERwFKntcWNZ+G+UPIsfBk3w3w5LG1R2ap3oHTHWHajjBtGG0kKZn XAdTm35wA0TxlxbaupYegMPR1U3OX7X0u9kgsUq0GV7w1+WLtMRO3pwZ/zg3nvoTNl1dmMFu31+ CJRNJApM2afEtFw== X-Developer-Key: i=bartosz.golaszewski@linaro.org; a=openpgp; fpr=169DEB6C0BC3C46013D2C79F11A72EA01471D772 From: Bartosz Golaszewski This module scans the device tree (for now only OF nodes are supported but care is taken to make other fwnode implementations easy to integrate) and determines which GPIO lines are shared by multiple users. It stores that information in memory. When the GPIO chip exposing shared lines is registered, the shared GPIO descriptors it exposes are marked as shared and virtual "proxy" devices that mediate access to the shared lines are created. When a consumer of a shared GPIO looks it up, its fwnode lookup is redirected to a just-in-time machine lookup that points to this proxy device. This code can be compiled out on platforms which don't use shared GPIOs. Signed-off-by: Bartosz Golaszewski --- drivers/gpio/Kconfig | 8 + drivers/gpio/Makefile | 1 + drivers/gpio/gpiolib-shared.c | 512 ++++++++++++++++++++++++++++++++++++++= ++++ drivers/gpio/gpiolib-shared.h | 71 ++++++ 4 files changed, 592 insertions(+) diff --git a/drivers/gpio/Kconfig b/drivers/gpio/Kconfig index 7ee3afbc2b05da4d7470e609a0311ecc38727b00..679a7385a9776eef96a86ca4f42= 9ee83ac939362 100644 --- a/drivers/gpio/Kconfig +++ b/drivers/gpio/Kconfig @@ -6,6 +6,9 @@ config GPIOLIB_LEGACY def_bool y =20 +config HAVE_SHARED_GPIOS + bool + menuconfig GPIOLIB bool "GPIO Support" help @@ -42,6 +45,11 @@ config GPIOLIB_IRQCHIP select IRQ_DOMAIN bool =20 +config GPIO_SHARED + def_bool y + depends on HAVE_SHARED_GPIOS || COMPILE_TEST + select AUXILIARY_BUS + config OF_GPIO_MM_GPIOCHIP bool help diff --git a/drivers/gpio/Makefile b/drivers/gpio/Makefile index ec296fa14bfdb360c27b4578826354762f01f074..f702f7e27e5b4017e7eab3019da= e4ec912d534f8 100644 --- a/drivers/gpio/Makefile +++ b/drivers/gpio/Makefile @@ -12,6 +12,7 @@ obj-$(CONFIG_GPIO_SYSFS) +=3D gpiolib-sysfs.o obj-$(CONFIG_GPIO_ACPI) +=3D gpiolib-acpi.o gpiolib-acpi-y :=3D gpiolib-acpi-core.o gpiolib-acpi-quirks.o obj-$(CONFIG_GPIOLIB) +=3D gpiolib-swnode.o +obj-$(CONFIG_GPIO_SHARED) +=3D gpiolib-shared.o =20 # Device drivers. Generally keep list sorted alphabetically obj-$(CONFIG_GPIO_REGMAP) +=3D gpio-regmap.o diff --git a/drivers/gpio/gpiolib-shared.c b/drivers/gpio/gpiolib-shared.c new file mode 100644 index 0000000000000000000000000000000000000000..d2087d0df4ab7bcd23d3736e341= c0f57cd748af4 --- /dev/null +++ b/drivers/gpio/gpiolib-shared.c @@ -0,0 +1,512 @@ +// 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 int gpio_shared_make_adev(struct gpio_device *gdev, + struct gpio_shared_ref *ref) +{ + struct auxiliary_device *adev =3D &ref->adev; + int ret; + + lockdep_assert_held(&gpio_shared_lock); + + memset(adev, 0, sizeof(*adev)); + + adev->id =3D ref->dev_id; + adev->name =3D "proxy"; + adev->dev.parent =3D gdev->dev.parent; + /* No need to dev->release() anything. */ + + ret =3D auxiliary_device_init(adev); + if (ret) + return ret; + + ret =3D auxiliary_device_add(adev); + if (ret) { + auxiliary_device_uninit(adev); + return ret; + } + + pr_debug("Created an auxiliary GPIO proxy %s for GPIO device %s\n", + dev_name(&adev->dev), gpio_device_get_label(gdev)); + + return 0; +} + +int gpio_shared_add_proxy_lookup(struct device *consumer, unsigned long lf= lags) +{ + const char *dev_id =3D dev_name(consumer); + struct gpio_shared_entry *entry; + struct gpio_shared_ref *ref; + + struct gpiod_lookup_table *lookup __free(kfree) =3D + kzalloc(struct_size(lookup, table, 2), GFP_KERNEL); + if (!lookup) + return -ENOMEM; + + guard(mutex)(&gpio_shared_lock); + + list_for_each_entry(entry, &gpio_shared_list, list) { + list_for_each_entry(ref, &entry->refs, list) { + if (!device_match_fwnode(consumer, ref->fwnode)) + continue; + + /* We've already done that on a previous request. */ + if (ref->lookup) + return 0; + + char *key __free(kfree) =3D + kasprintf(GFP_KERNEL, + KBUILD_MODNAME ".proxy.%u", + ref->adev.id); + if (!key) + return -ENOMEM; + + pr_debug("Adding machine lookup entry for a shared GPIO for consumer %s= , with key '%s' and con_id '%s'\n", + dev_id, key, ref->con_id ?: "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); +} + +struct gpio_shared_desc *devm_gpiod_shared_get(struct device *dev) +{ + struct auxiliary_device *adev =3D to_auxiliary_dev(dev); + struct gpio_shared_desc *shared_desc; + struct gpio_shared_entry *entry; + struct gpio_shared_ref *ref; + struct gpio_device *gdev; + int ret; + + scoped_guard(mutex, &gpio_shared_lock) { + list_for_each_entry(entry, &gpio_shared_list, list) { + list_for_each_entry(ref, &entry->refs, list) { + if (adev !=3D &ref->adev) + continue; + + if (entry->shared_desc) { + kref_get(&entry->ref); + shared_desc =3D entry->shared_desc; + break; + } + + shared_desc =3D kzalloc(sizeof(*shared_desc), GFP_KERNEL); + if (!shared_desc) + return ERR_PTR(-ENOMEM); + + gdev =3D gpio_device_find_by_fwnode(entry->fwnode); + if (!gdev) { + kfree(shared_desc); + return ERR_PTR(-EPROBE_DEFER); + } + + shared_desc->desc =3D &gdev->descs[entry->offset]; + shared_desc->can_sleep =3D gpiod_cansleep(shared_desc->desc); + if (shared_desc->can_sleep) + mutex_init(&shared_desc->mutex); + else + spin_lock_init(&shared_desc->spinlock); + + kref_init(&entry->ref); + entry->shared_desc =3D shared_desc; + + pr_debug("Device %s acquired a reference to the shared GPIO %u owned b= y %s\n", + dev_name(dev), desc_to_gpio(shared_desc->desc), + gpio_device_get_label(gdev)); + break; + } + } + } + + ret =3D devm_add_action_or_reset(dev, gpiod_shared_put, entry); + if (ret) + return ERR_PTR(ret); + + return shared_desc; +} +EXPORT_SYMBOL_GPL(devm_gpiod_shared_get); + +static void gpio_shared_drop_ref(struct gpio_shared_ref *ref) +{ + list_del(&ref->list); + kfree(ref->con_id); + ida_free(&gpio_shared_ida, ref->dev_id); + fwnode_handle_put(ref->fwnode); + kfree(ref); +} + +static void gpio_shared_drop_entry(struct gpio_shared_entry *entry) +{ + list_del(&entry->list); + fwnode_handle_put(entry->fwnode); + kfree(entry); +} + +/* + * This is only called if gpio_shared_init() fails so it's in fact __init = and + * not __exit. + */ +static void __init gpio_shared_teardown(void) +{ + struct gpio_shared_entry *entry, *epos; + struct gpio_shared_ref *ref, *rpos; + + list_for_each_entry_safe(entry, epos, &gpio_shared_list, list) { + list_for_each_entry_safe(ref, rpos, &entry->refs, list) + gpio_shared_drop_ref(ref); + + gpio_shared_drop_entry(entry); + } +} + +static void gpio_shared_free_exclusive(void) +{ + struct gpio_shared_entry *entry, *epos; + + list_for_each_entry_safe(entry, epos, &gpio_shared_list, list) { + if (list_count_nodes(&entry->refs) > 1) + continue; + + gpio_shared_drop_ref(list_first_entry(&entry->refs, + struct gpio_shared_ref, + list)); + gpio_shared_drop_entry(entry); + } +} + +static int __init gpio_shared_init(void) +{ + int ret; + + /* Right now, we only support OF-based systems. */ + ret =3D gpio_shared_of_scan(); + if (ret) { + gpio_shared_teardown(); + pr_err("Failed to scan OF nodes for shared GPIOs: %d\n", ret); + return ret; + } + + gpio_shared_free_exclusive(); + + pr_debug("Finished scanning firmware nodes for shared GPIOs\n"); + return 0; +} +postcore_initcall(gpio_shared_init); diff --git a/drivers/gpio/gpiolib-shared.h b/drivers/gpio/gpiolib-shared.h new file mode 100644 index 0000000000000000000000000000000000000000..667dbdff3585066b7cbe2ebe476= 725fe7d683d84 --- /dev/null +++ b/drivers/gpio/gpiolib-shared.h @@ -0,0 +1,71 @@ +/* SPDX-License-Identifier: GPL-2.0 */ + +#ifndef __LINUX_GPIO_SHARED_H +#define __LINUX_GPIO_SHARED_H + +#include +#include +#include +#include + +struct gpio_device; +struct gpio_desc; +struct device; + +#if IS_ENABLED(CONFIG_GPIO_SHARED) + +int gpio_device_setup_shared(struct gpio_device *gdev); +void gpio_device_teardown_shared(struct gpio_device *gdev); +int gpio_shared_add_proxy_lookup(struct device *consumer, unsigned long lf= lags); + +#else + +static inline int gpio_device_setup_shared(struct gpio_device *gdev) +{ + return 0; +} + +static inline void gpio_device_teardown_shared(struct gpio_device *gdev) {= } + +static inline int gpio_shared_add_proxy_lookup(struct device *consumer, + unsigned long lflags) +{ + return 0; +} + +#endif /* CONFIG_GPIO_SHARED */ + +struct gpio_shared_desc { + struct gpio_desc *desc; + bool can_sleep; + unsigned long cfg; + unsigned int usecnt; + unsigned int highcnt; + union { + struct mutex mutex; + spinlock_t spinlock; + }; +}; + +struct gpio_shared_desc *devm_gpiod_shared_get(struct device *dev); + +DEFINE_LOCK_GUARD_1(gpio_shared_desc_lock, struct gpio_shared_desc, + if (_T->lock->can_sleep) + mutex_lock(&_T->lock->mutex); + else + spin_lock_irqsave(&_T->lock->spinlock, _T->flags), + if (_T->lock->can_sleep) + mutex_unlock(&_T->lock->mutex); + else + spin_unlock_irqrestore(&_T->lock->spinlock, _T->flags), + unsigned long flags) + +static inline void gpio_shared_lockdep_assert(struct gpio_shared_desc *sha= red_desc) +{ + if (shared_desc->can_sleep) + lockdep_assert_held(&shared_desc->mutex); + else + lockdep_assert_held(&shared_desc->spinlock); +} + +#endif /* __LINUX_GPIO_SHARED_H */ --=20 2.48.1 From nobody Sat Feb 7 23:48:06 2026 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 9A4CC348877 for ; Wed, 22 Oct 2025 13:11:10 +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=1761138673; cv=none; b=W4LndFAv/WWg5mN9eZL5zH8pflSwuLlaYYC5bZwZZNkgLSoFeeiK9FMKlxlneBwyHPwJt1XPPdsbSRYHbt9rwU3QRI6o2Hm9UOGDjChpDVevqfSrs+80p0qdVzLTbHSOlWenADhmr2C+35390p6UGXJ2PABJkoXY1AXnGcEj/+I= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1761138673; c=relaxed/simple; bh=PEW5VfmwKxTEd1s5F2KY5fqrtDh/1gqVWns6m/YBKno=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=a9qNy2H7grvJFEhfoc3VoNbpr5/WmsSAGgKJXq3j9/2kQfPa45+xz4KjuGnKu0dktlqwHtfagMfKOlAJDMM8u/VLPxOL96dkwrmXjzroFUQR4GtZoECHXpUMXUECi6bn/xrFHg0C6Wgc5PHHK3jGYdy6UfqZsyJbaUfWUehHkSA= 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=n6FhFHt3; 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="n6FhFHt3" Received: by mail-wm1-f42.google.com with SMTP id 5b1f17b1804b1-47118259fd8so43227255e9.3 for ; Wed, 22 Oct 2025 06:11:10 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=bgdev-pl.20230601.gappssmtp.com; s=20230601; t=1761138669; x=1761743469; 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=xxefnDuFAgbuOWtzWxnGFUx9Bz27z/Zir2kMC7KD/PA=; b=n6FhFHt3Tlqr3H6IKDiXhw9YkNDLw6RCx2+0KUNbqMwbL65o69srHgkicovhebXStE LlNvWkm7nr+jAudPSklFyHimuaIih2a0gnqxNG+yjpxhgK4Kn/HFMDNBlVyAYBfLgDQM 6UsT3t0kIWwM0SvxE9rdYf3ynon0NKarn5lBmKF8M386XzgF5WOpWPLrrXtVk0avQ7Z1 gcRQMhbjD9yUsBkQnoq6fN6Ow/sea7BJuvMixtK1VCeOamuYHslDvYHwjKmwr4XLTj9C EDef+XcAY6ZUUiJanc2HavqQtk/edg8M5IozUc5InO47kFGJEH/u7XQmIeIZk+lTh4xk TiTA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1761138669; x=1761743469; h=cc:to:in-reply-to:references:message-id:content-transfer-encoding :mime-version:subject:date:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=xxefnDuFAgbuOWtzWxnGFUx9Bz27z/Zir2kMC7KD/PA=; b=MAQ4VHXeCKrJTfkCdvHwye4t1AvG/+Kv3Y4+ugztLCrpbbrgKkTzND13LQIE5n6vzB OOqfhBbbNKZlrEzhQn369p6TKGl8PR2UQftiv8Q9WNrdP9HBkCW0HCKRTdWY0G+FrAGP rmHBshaQ9ff9RzBnjlj76SXUEKvX+OJFW+4foLqzTFKcNsbIKQ7pXFQ+Bjgf6wMQDtpE KUjguWpQ7M7R5Z5NqN2ADR4dC4U/oPG5oFTq4bF2+aLWmbTmXzckZPG1JxyWIwK43Occ gZ6Sj2uKnMHdU0o/6ouN3S7Ztju6vAwL9QNrCoXwu36vd+9sIGHRKfvE2mTBN9crou9y 7Dxg== X-Forwarded-Encrypted: i=1; AJvYcCUB7Fybf1YRdxq5ilt9TIizq5jNl9GzfnHR2yIPtuY+hUAHCxsb2ujcbBwYC4EDsn2+oNTX+MrYkNmaJxI=@vger.kernel.org X-Gm-Message-State: AOJu0YwKRem3szavTaH8W43FnNPJreLlTUhCkyVLESNbuS5qNDxP9Bmv ZXGG+0LAtvXv65QgvQi827EHnplGlWPCTuJ5PbQ5jr6vCKpplz/leJmHb1JQRUv/5hI= X-Gm-Gg: ASbGncvYrQGH5StMF4GEcJQzbJ9vKhwOcjiMh3LQuvUZcQMQNl+loSfN8Pnr9hwnW0k JLgZQhQNm2uqSJOrJZh8Q1FKWhmWVyuAO/nOVDDw7wDrpsmAa8ov4iiNamsJPnW+3MpDYVbRymA ZG7ticbCkniqMQ+TCVQ/CIuCvDJiqLOgtKRXK9rVAe9fdVwZA0yuMRAOjoqId9EqxKe6p1yQPTd uyKlSRsw/0xEzsY3UxyuA9A9VTm3XgzSPMTw4/PdTVaXwM0SAAcOUeoxDvlujq4BudOPUKLINaX hJNojq8PrtGfl3K0pa46sznvo6A66auNYcFt6hAM+cYlJjWie33xo1KeqW2nksIo4i7V0JwvReh +0IrlO+fBWTBiYk4pXwId6QxLa9B8/eIEqpvMBt/0NVbBM75sEnRv1NVYmZ12xhxF6qmInZU= X-Google-Smtp-Source: AGHT+IGwD09QAVGKkMJ5ze7OXZXe7q4kSFTqb0MMW6OeeC8cs5RR1p82ufb6WAVaKR6I6Zzal79dWQ== X-Received: by 2002:a05:600c:3555:b0:470:fe3c:a3b7 with SMTP id 5b1f17b1804b1-4711786d42dmr154030255e9.5.1761138668613; Wed, 22 Oct 2025 06:11:08 -0700 (PDT) Received: from [127.0.1.1] ([2a01:cb1d:dc:7e00:69df:73af:f16a:eada]) by smtp.gmail.com with ESMTPSA id 5b1f17b1804b1-47496afd459sm38839905e9.1.2025.10.22.06.11.05 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 22 Oct 2025 06:11:05 -0700 (PDT) From: Bartosz Golaszewski Date: Wed, 22 Oct 2025 15:10:43 +0200 Subject: [PATCH v2 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: <20251022-gpio-shared-v2-4-d34aa1fbdf06@linaro.org> References: <20251022-gpio-shared-v2-0-d34aa1fbdf06@linaro.org> In-Reply-To: <20251022-gpio-shared-v2-0-d34aa1fbdf06@linaro.org> To: Kees Cook , Mika Westerberg , Dmitry Torokhov , Andrew Morton , Linus Walleij , Manivannan Sadhasivam , Rob Herring , Krzysztof Kozlowski , Conor Dooley , Saravana Kannan , Greg Kroah-Hartman , Andy Shevchenko , Bartosz Golaszewski , Catalin Marinas , Will Deacon , Srinivas Kandagatla , Liam Girdwood , Mark Brown , Jaroslav Kysela , Takashi Iwai Cc: linux-hardening@vger.kernel.org, linux-kernel@vger.kernel.org, linux-gpio@vger.kernel.org, linux-arm-kernel@lists.infradead.org, linux-sound@vger.kernel.org, linux-arm-msm@vger.kernel.org, Bartosz Golaszewski X-Mailer: b4 0.14.2 X-Developer-Signature: v=1; a=openpgp-sha256; l=11952; i=bartosz.golaszewski@linaro.org; h=from:subject:message-id; bh=4uKGAjNhsLa5igkAFf7fdbFeEXJRT/s3+XJIBfGT0lk=; b=owEBbQKS/ZANAwAKARGnLqAUcddyAcsmYgBo+Nfd3bW7DRvSgrszLV/ABY7xyATTCs546XrvV rAnfLXdJpaJAjMEAAEKAB0WIQQWnetsC8PEYBPSx58Rpy6gFHHXcgUCaPjX3QAKCRARpy6gFHHX cpqmD/9i7psfG399MXY3NXK0CHucr13M79HAfxnt7gqJ/YQh6ITnU+nOKoarbi9PqZBhcNbsN1n SpnR89KWXZqY55/2CURR2/kXLmxFb+RUi4mbkESeF3tSG4P4xgRpgutOf3En8loLtoKMV38ZZTq Ffo280Ikv2yM2JWoc+nqcGml4u3MsPc2YroWYpa7E4jb40ozPrARNO4EsCVtntu2p/ImyFO/311 QoSrUsfuZqeG0FJAIp9xha+9MS0CUDCcd0ljW2F55jCwftIm/9BGMCCqyV4L1f7kg68JdgNiMF1 82AzMc4ixjgbHOvcbJOFnpZ0y/5HzE5Ih8NAW0w5ru+J+sZKMVoPxpJrPgpLWPFgdRkPuur054k nrqbEj09cNfGEgNc1p9Zm+7/Wod4L1YUfkMyd8pIRDjFIO3ozGv3zaEuOMdCVait/+1C89rSCuB p5EVmmcjTeIrJ+CTULGcQAd5JkDZr9BZPaNOZoL4RbRKgqHOjmmhCHbk8tZlZSjYNHHH4TB17J7 kn/U/lyA0jqbbfK47EXAWBAec85JJWJmSXdBj7I3e+3PaJssEzBokXhSWcVf+2STPTrfEQLNc5P 4cSGGmaUJwhicADyaht2xcQJ+ZZlfLtMvuCrVWjQD62ra0JLVqRaY1U15IA637/BMGuXn4OYX5E pbAMp6FAiLXUiag== X-Developer-Key: i=bartosz.golaszewski@linaro.org; a=openpgp; fpr=169DEB6C0BC3C46013D2C79F11A72EA01471D772 From: Bartosz Golaszewski Add a virtual GPIO proxy driver which arbitrates access to a single shared GPIO by multiple users. It works together with the core shared GPIO support from GPIOLIB and functions by acquiring a reference to a shared GPIO descriptor exposed by gpiolib-shared and making sure that the state of the GPIO stays consistent. In general: if there's only one user at the moment: allow it to do anything as if this was a normal GPIO (in essence: just propagate calls to the underlying real hardware driver). If there are more users: don't allow to change the direction set by the initial user, allow to change configuration options but warn about possible conflicts and finally: treat the output-high value as a reference counted, logical "GPIO enabled" setting, meaning: the GPIO value is set to high when the first user requests it to be high and back to low once the last user stops "voting" for high. Signed-off-by: Bartosz Golaszewski --- drivers/gpio/Kconfig | 9 ++ drivers/gpio/Makefile | 1 + drivers/gpio/gpio-shared-proxy.c | 329 +++++++++++++++++++++++++++++++++++= ++++ 3 files changed, 339 insertions(+) diff --git a/drivers/gpio/Kconfig b/drivers/gpio/Kconfig index 679a7385a9776eef96a86ca4f429ee83ac939362..de8e4febf344fc19a633cd7efe8= 412fe12166fb8 100644 --- a/drivers/gpio/Kconfig +++ b/drivers/gpio/Kconfig @@ -2025,6 +2025,15 @@ config GPIO_SIM This enables the GPIO simulator - a configfs-based GPIO testing driver. =20 +config GPIO_SHARED_PROXY + tristate "Proxy driver for non-exclusive GPIOs" + default m + depends on GPIO_SHARED || COMPILE_TEST + select AUXILIARY_BUS + help + This enables the GPIO shared proxy driver - an abstraction layer + for GPIO pins that are shared by multiple devices. + endmenu =20 menu "GPIO Debugging utilities" diff --git a/drivers/gpio/Makefile b/drivers/gpio/Makefile index f702f7e27e5b4017e7eab3019dae4ec912d534f8..d0020bc70b84f6fb9949165070c= 21725a60f47e2 100644 --- a/drivers/gpio/Makefile +++ b/drivers/gpio/Makefile @@ -160,6 +160,7 @@ obj-$(CONFIG_ARCH_SA1100) +=3D gpio-sa1100.o obj-$(CONFIG_GPIO_SAMA5D2_PIOBU) +=3D gpio-sama5d2-piobu.o obj-$(CONFIG_GPIO_SCH311X) +=3D gpio-sch311x.o obj-$(CONFIG_GPIO_SCH) +=3D gpio-sch.o +obj-$(CONFIG_GPIO_SHARED_PROXY) +=3D gpio-shared-proxy.o obj-$(CONFIG_GPIO_SIFIVE) +=3D gpio-sifive.o obj-$(CONFIG_GPIO_SIM) +=3D gpio-sim.o obj-$(CONFIG_GPIO_SIOX) +=3D gpio-siox.o diff --git a/drivers/gpio/gpio-shared-proxy.c b/drivers/gpio/gpio-shared-pr= oxy.c new file mode 100644 index 0000000000000000000000000000000000000000..9b3dd875a5ad9f56ca9d27f6f22= 46eb854829f1f --- /dev/null +++ b/drivers/gpio/gpio-shared-proxy.c @@ -0,0 +1,329 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* + * Copyright (C) 2025 Linaro Ltd. + */ + +#include +#include +#include +#include +#include +#include + +#include "gpiolib-shared.h" + +struct gpio_shared_proxy_data { + struct gpio_chip gc; + struct gpio_shared_desc *shared_desc; + struct device *dev; + bool voted_high; +}; + +static int +gpio_shared_proxy_set_unlocked(struct gpio_shared_proxy_data *proxy, + int (*set_func)(struct gpio_desc *desc, int value), + int value) +{ + struct gpio_shared_desc *shared_desc =3D proxy->shared_desc; + struct gpio_desc *desc =3D shared_desc->desc; + int ret =3D 0; + + gpio_shared_lockdep_assert(shared_desc); + + if (value) { + /* User wants to set value to high. */ + if (proxy->voted_high) + /* Already voted for high, nothing to do. */ + goto out; + + /* Haven't voted for high yet. */ + if (!shared_desc->highcnt) { + /* + * Current value is low, need to actually set value + * to high. + */ + ret =3D set_func(desc, 1); + if (ret) + goto out; + } + + shared_desc->highcnt++; + proxy->voted_high =3D true; + + goto out; + } + + /* Desired value is low. */ + if (!proxy->voted_high) + /* We didn't vote for high, nothing to do. */ + goto out; + + /* We previously voted for high. */ + if (shared_desc->highcnt =3D=3D 1) { + /* This is the last remaining vote for high, set value to low. */ + ret =3D set_func(desc, 0); + if (ret) + goto out; + } + + shared_desc->highcnt--; + proxy->voted_high =3D false; + +out: + if (shared_desc->highcnt) + dev_dbg(proxy->dev, + "Voted for value '%s', effective value is 'high', number of votes for '= high': %u\n", + value ? "high" : "low", shared_desc->highcnt); + else + dev_dbg(proxy->dev, "Voted for value 'low', effective value is 'low'\n"); + + return ret; +} + +static int gpio_shared_proxy_request(struct gpio_chip *gc, unsigned int of= fset) +{ + struct gpio_shared_proxy_data *proxy =3D gpiochip_get_data(gc); + struct gpio_shared_desc *shared_desc =3D proxy->shared_desc; + + guard(gpio_shared_desc_lock)(shared_desc); + + proxy->shared_desc->usecnt++; + + dev_dbg(proxy->dev, "Shared GPIO requested, number of users: %u\n", + proxy->shared_desc->usecnt); + + return 0; +} + +static void gpio_shared_proxy_free(struct gpio_chip *gc, unsigned int offs= et) +{ + struct gpio_shared_proxy_data *proxy =3D gpiochip_get_data(gc); + struct gpio_shared_desc *shared_desc =3D proxy->shared_desc; + + guard(gpio_shared_desc_lock)(shared_desc); + + proxy->shared_desc->usecnt--; + + dev_dbg(proxy->dev, "Shared GPIO freed, number of users: %u\n", + proxy->shared_desc->usecnt); +} + +static int gpio_shared_proxy_set_config(struct gpio_chip *gc, + unsigned int offset, unsigned long cfg) +{ + struct gpio_shared_proxy_data *proxy =3D gpiochip_get_data(gc); + struct gpio_shared_desc *shared_desc =3D proxy->shared_desc; + struct gpio_desc *desc =3D shared_desc->desc; + int ret; + + guard(gpio_shared_desc_lock)(shared_desc); + + if (shared_desc->usecnt > 1) { + if (shared_desc->cfg !=3D cfg) { + dev_dbg(proxy->dev, + "Shared GPIO's configuration already set, accepting changes but users = may conflict!!\n"); + } else { + dev_dbg(proxy->dev, "Equal config requested, nothing to do\n"); + return 0; + } + } + + ret =3D gpiod_set_config(desc, cfg); + if (ret && ret !=3D -ENOTSUPP) + return ret; + + shared_desc->cfg =3D cfg; + return 0; +} + +static int gpio_shared_proxy_direction_input(struct gpio_chip *gc, + unsigned int offset) +{ + struct gpio_shared_proxy_data *proxy =3D gpiochip_get_data(gc); + struct gpio_shared_desc *shared_desc =3D proxy->shared_desc; + struct gpio_desc *desc =3D shared_desc->desc; + int dir; + + guard(gpio_shared_desc_lock)(shared_desc); + + if (shared_desc->usecnt =3D=3D 1) { + dev_dbg(proxy->dev, + "Only one user of this shared GPIO, allowing to set direction to input\= n"); + + return gpiod_direction_input(desc); + } + + dir =3D gpiod_get_direction(desc); + if (dir < 0) + return dir; + + if (dir =3D=3D GPIO_LINE_DIRECTION_OUT) { + dev_dbg(proxy->dev, + "Shared GPIO's direction already set to output, refusing to change\n"); + return -EPERM; + } + + return 0; +} + +static int gpio_shared_proxy_direction_output(struct gpio_chip *gc, + unsigned int offset, int value) +{ + struct gpio_shared_proxy_data *proxy =3D gpiochip_get_data(gc); + struct gpio_shared_desc *shared_desc =3D proxy->shared_desc; + struct gpio_desc *desc =3D shared_desc->desc; + int ret, dir; + + guard(gpio_shared_desc_lock)(shared_desc); + + if (shared_desc->usecnt =3D=3D 1) { + dev_dbg(proxy->dev, + "Only one user of this shared GPIO, allowing to set direction to output= with value '%s'\n", + value ? "high" : "low"); + + ret =3D gpiod_direction_output(desc, value); + if (ret) + return ret; + + if (value) { + proxy->voted_high =3D true; + shared_desc->highcnt =3D 1; + } else { + proxy->voted_high =3D false; + shared_desc->highcnt =3D 0; + } + + return 0; + } + + dir =3D gpiod_get_direction(desc); + if (dir < 0) + return dir; + + if (dir =3D=3D GPIO_LINE_DIRECTION_IN) { + dev_dbg(proxy->dev, + "Shared GPIO's direction already set to input, refusing to change\n"); + return -EPERM; + } + + return gpio_shared_proxy_set_unlocked(proxy, gpiod_direction_output, valu= e); +} + +static int gpio_shared_proxy_get(struct gpio_chip *gc, unsigned int offset) +{ + struct gpio_shared_proxy_data *proxy =3D gpiochip_get_data(gc); + + return gpiod_get_value(proxy->shared_desc->desc); +} + +static int gpio_shared_proxy_get_cansleep(struct gpio_chip *gc, + unsigned int offset) +{ + struct gpio_shared_proxy_data *proxy =3D gpiochip_get_data(gc); + + return gpiod_get_value_cansleep(proxy->shared_desc->desc); +} + +static int gpio_shared_proxy_do_set(struct gpio_shared_proxy_data *proxy, + int (*set_func)(struct gpio_desc *desc, int value), + int value) +{ + guard(gpio_shared_desc_lock)(proxy->shared_desc); + + return gpio_shared_proxy_set_unlocked(proxy, set_func, value); +} + +static int gpio_shared_proxy_set(struct gpio_chip *gc, unsigned int offset, + int value) +{ + struct gpio_shared_proxy_data *proxy =3D gpiochip_get_data(gc); + + return gpio_shared_proxy_do_set(proxy, gpiod_set_value, value); +} + +static int gpio_shared_proxy_set_cansleep(struct gpio_chip *gc, + unsigned int offset, int value) +{ + struct gpio_shared_proxy_data *proxy =3D gpiochip_get_data(gc); + + return gpio_shared_proxy_do_set(proxy, gpiod_set_value_cansleep, value); +} + +static int gpio_shared_proxy_get_direction(struct gpio_chip *gc, + unsigned int offset) +{ + struct gpio_shared_proxy_data *proxy =3D gpiochip_get_data(gc); + + return gpiod_get_direction(proxy->shared_desc->desc); +} + +static int gpio_shared_proxy_to_irq(struct gpio_chip *gc, unsigned int off= set) +{ + struct gpio_shared_proxy_data *proxy =3D gpiochip_get_data(gc); + + return gpiod_to_irq(proxy->shared_desc->desc); +} + +static int gpio_shared_proxy_probe(struct auxiliary_device *adev, + const struct auxiliary_device_id *id) +{ + struct gpio_shared_proxy_data *proxy; + struct gpio_shared_desc *shared_desc; + struct device *dev =3D &adev->dev; + struct gpio_chip *gc; + + shared_desc =3D devm_gpiod_shared_get(dev); + if (IS_ERR(shared_desc)) + return PTR_ERR(shared_desc); + + proxy =3D devm_kzalloc(dev, sizeof(*proxy), GFP_KERNEL); + if (!proxy) + return -ENOMEM; + + proxy->shared_desc =3D shared_desc; + proxy->dev =3D dev; + + gc =3D &proxy->gc; + gc->base =3D -1; + gc->ngpio =3D 1; + gc->label =3D dev_name(dev); + gc->parent =3D dev; + gc->owner =3D THIS_MODULE; + gc->can_sleep =3D shared_desc->can_sleep; + + gc->request =3D gpio_shared_proxy_request; + gc->free =3D gpio_shared_proxy_free; + gc->set_config =3D gpio_shared_proxy_set_config; + gc->direction_input =3D gpio_shared_proxy_direction_input; + gc->direction_output =3D gpio_shared_proxy_direction_output; + if (gc->can_sleep) { + gc->set =3D gpio_shared_proxy_set_cansleep; + gc->get =3D gpio_shared_proxy_get_cansleep; + } else { + gc->set =3D gpio_shared_proxy_set; + gc->get =3D gpio_shared_proxy_get; + } + gc->get_direction =3D gpio_shared_proxy_get_direction; + gc->to_irq =3D gpio_shared_proxy_to_irq; + + return devm_gpiochip_add_data(dev, &proxy->gc, proxy); +} + +static const struct auxiliary_device_id gpio_shared_proxy_id_table[] =3D { + { .name =3D "gpiolib_shared.proxy" }, + {}, +}; +MODULE_DEVICE_TABLE(auxiliary, gpio_shared_proxy_id_table); + +static struct auxiliary_driver gpio_shared_proxy_driver =3D { + .driver =3D { + .name =3D "gpio-shared-proxy", + }, + .probe =3D gpio_shared_proxy_probe, + .id_table =3D gpio_shared_proxy_id_table, +}; +module_auxiliary_driver(gpio_shared_proxy_driver); + +MODULE_AUTHOR("Bartosz Golaszewski "); +MODULE_DESCRIPTION("Shared GPIO mux driver."); +MODULE_LICENSE("GPL"); --=20 2.48.1 From nobody Sat Feb 7 23:48:06 2026 Received: from mail-wm1-f52.google.com (mail-wm1-f52.google.com [209.85.128.52]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id C182834A777 for ; Wed, 22 Oct 2025 13:11:12 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.128.52 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1761138674; cv=none; b=Uq0Ax5pHfMb0NoTpZ1ka0pEHCOCXHNsZIRCKjfNpmQnhq3TgUjfpLOe5I6XddOtM3FGAfZFTmlo5sF7YoVXDKg5G9k+p4LV6gQt3rM/jdzVNLUXmLcajWv3fgQNJ+O1IesfYnuH5fZEsh38ndbG7CAbdpECHumgDAvj8kKK3LaQ= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1761138674; c=relaxed/simple; bh=LPm9YBzUQ4gQfPx8tMp97rKvgm+IC1c2b9DnnDCOC8U=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=c1W0U7ThOuX7leLajhO5ip9Wv9qxY/JPBc5nLcr9cTNzpQbOPgZg6ECXufY7X+k8AQzugpLKFx9EnhHOf4+PNkr8qU2hsq+g4P20s8hxUWs+pT3RibM099fX3DcINV4VhuqM29Dzj+C8S0/+omUobynY41OpnPuWQDTu8GdafmA= 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=Gfi4QrAn; arc=none smtp.client-ip=209.85.128.52 Authentication-Results: smtp.subspace.kernel.org; dmarc=none (p=none dis=none) header.from=bgdev.pl Authentication-Results: smtp.subspace.kernel.org; spf=none smtp.mailfrom=bgdev.pl Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=bgdev-pl.20230601.gappssmtp.com header.i=@bgdev-pl.20230601.gappssmtp.com header.b="Gfi4QrAn" Received: by mail-wm1-f52.google.com with SMTP id 5b1f17b1804b1-47114a40161so26769075e9.3 for ; Wed, 22 Oct 2025 06:11:12 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=bgdev-pl.20230601.gappssmtp.com; s=20230601; t=1761138671; x=1761743471; 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=7JxC4wP5bi/PqrvaNLx4qtWBYafzvA8adhEOxdIGx4g=; b=Gfi4QrAnssPfFlc8pR1BSuXZ1EpTExNqaLGYPZgcUy5g4e4iI4A14wO5mSBbcATMJh 7iiHEAWxWoRwkGLtdIJ0Z3rUWeo5ba0Aq/+RAxFT6PDBrUcqBJ1Qu9wNiJ4HGUjLo7gR 7BGnQMn1pvLab7aTPyFlyjPaqX9hJq0QoUb5+Ip3hnRwDQl8+MB0ELQdy98eob6LhyFf E03NzoE/c3ONIt7TZ510pz/sJyYbsSEyvLsrFUf007UeT0RFIuhQ2aA92gD3dF9BfEUA 7VBBRLpxDczniy2/xzsP3VsfPtfr0sK0blhcK0VCVCH9o0lvChrJ/ORUjdNZGxLYAP/P 68Gg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1761138671; x=1761743471; h=cc:to:in-reply-to:references:message-id:content-transfer-encoding :mime-version:subject:date:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=7JxC4wP5bi/PqrvaNLx4qtWBYafzvA8adhEOxdIGx4g=; b=Ef1OnolOt3Y8XRQEYgudcXZe+tMfc0o3OpwZHU7IUnYez3h/U+gys01/XduEmUc4cO h+LWa2LglzWVrat5efYRKqEw3r1T9Uvk5r/grcnQy65v/qeCOfXXKgTh30A4SsW/zUPu K6PNz857nZICMKfz1dDq/UOsxde8+KVoANTjzMC2FyJOm/Iq+DhYBHiLCldazoZMfABl x8MegWMeY1ZXyt283reTwA6bpn6cjoApZCeJQeVEp9KDSaBtOicVsfwESd0EiuGPOvgu UaEnOa7In/pYE8+l8XPmYQ40RZskIDl0k2gOA98cofSZO+5vjtgr7YToVh4Zq2Hs3hNa bwUA== X-Forwarded-Encrypted: i=1; AJvYcCUS3VU006u/IrobU4jXbJM94zfwBF70QFaZg/Ayk5Lq410XuSbzFWmqIIxM2Tqjar4IbhGyHVwEVDmy6bY=@vger.kernel.org X-Gm-Message-State: AOJu0YzYQStmOpSzGMsjFp/iKx0sEkY5DqgDsdzTU51NFGWno4TV+V6d 8skq4srlKWowGhfXju3X/feQB/de8BDSzdvWGXcOiltJGZY5f6TvUyWfZW/AKBDK8QA= X-Gm-Gg: ASbGnctdMbayabey/K53N87A74Fw4W9L9QGJ1refLLlKV67otgM6tOVjZKA1oQiBXhc bmZ1cRUT5KYpr4JQwS4XYGR2zk+D7m1SOHr1kSqoK6YlccruoomDMbCFICONZDVfsFxOlUS9JGF /jlZBpDqw/RAbJI8BnaZMtaGPmq/w9sDvbPW35XnQVQSRSPBLHQB6zmDE46hSwMmJtrRNFfV3zO hNPLQRfJEyPWytIc+9Jc6LuqTygBf391FP5srwODjoabY6Gfs4GIOJXEsXS5FdncdzuDE9ywGiq K8qhfiQdZhzeYT2Jun84qcJ4tneoYOVRe+GHGYiFgA24gLbxmdKMftFCgy/5+f9Mi8QWb+2jyAv X5t55DZ+P5V4iWqVuQvh77k9/Zg2Jf6MdLNStS/DAR/qbILGagmJVe5xB+kBGQk0j5fvxhrU= X-Google-Smtp-Source: AGHT+IHo7fpOJ7A4/PDFJApxVJPuvZ2+KhtSRrGrKQkN9hTz6RoVFtBwlxLDGySMMqM9OycqmRHnhw== X-Received: by 2002:a05:600c:3e07:b0:46e:450d:e037 with SMTP id 5b1f17b1804b1-4711786c560mr160425345e9.5.1761138671092; Wed, 22 Oct 2025 06:11:11 -0700 (PDT) Received: from [127.0.1.1] ([2a01:cb1d:dc:7e00:69df:73af:f16a:eada]) by smtp.gmail.com with ESMTPSA id 5b1f17b1804b1-47496afd459sm38839905e9.1.2025.10.22.06.11.08 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 22 Oct 2025 06:11:09 -0700 (PDT) From: Bartosz Golaszewski Date: Wed, 22 Oct 2025 15:10:44 +0200 Subject: [PATCH v2 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: <20251022-gpio-shared-v2-5-d34aa1fbdf06@linaro.org> References: <20251022-gpio-shared-v2-0-d34aa1fbdf06@linaro.org> In-Reply-To: <20251022-gpio-shared-v2-0-d34aa1fbdf06@linaro.org> To: Kees Cook , Mika Westerberg , Dmitry Torokhov , Andrew Morton , Linus Walleij , Manivannan Sadhasivam , Rob Herring , Krzysztof Kozlowski , Conor Dooley , Saravana Kannan , Greg Kroah-Hartman , Andy Shevchenko , Bartosz Golaszewski , Catalin Marinas , Will Deacon , Srinivas Kandagatla , Liam Girdwood , Mark Brown , Jaroslav Kysela , Takashi Iwai Cc: linux-hardening@vger.kernel.org, linux-kernel@vger.kernel.org, linux-gpio@vger.kernel.org, linux-arm-kernel@lists.infradead.org, linux-sound@vger.kernel.org, linux-arm-msm@vger.kernel.org, Bartosz Golaszewski X-Mailer: b4 0.14.2 X-Developer-Signature: v=1; a=openpgp-sha256; l=4422; i=bartosz.golaszewski@linaro.org; h=from:subject:message-id; bh=zqXCTaI+O2fDGRyRHcv5jGy43WgDG3dY8izHkuOqT+8=; b=owEBbQKS/ZANAwAKARGnLqAUcddyAcsmYgBo+NfdN6WlD8MNTI0j9WttuM9GjMl2b/JJHHe5o KvW0ta3RKaJAjMEAAEKAB0WIQQWnetsC8PEYBPSx58Rpy6gFHHXcgUCaPjX3QAKCRARpy6gFHHX cqSuD/9q1cd7HMe1XSEd4nF6dgis0elTdxxSKaEEOn4CmMimW6BoSdKLxlhAjaUYHolIY3lso6q FvKuLQ2VYwRNhHYvR2ZyjsPNv1adhD8f9WaAD9qjMJX942vR9KW4DYf7u83G+fMRXTW01V0x4tA sYHA44FyHa5JRbjKnYc0AjlnS3Rj50FjhhJWALXcI3YWU/sqcu90aof58IAI3hZQ/35j9i++VAz KoON8D4dPHJONeZh5VpM4guVUN5GRz3scQtiUlqE7Zb+QkL5pjX8Y8K2XkdSVh5Qjr4jJwmI2f/ FcHboakvuRX4D8eBfb6B3ctXaQN8gjBOjkBo316BiDVQAMdkyU8GyoKptnm4howzrP1El0SHW8L Yh57Q8C+nVmRnqpJE5h9gPsg3MLEpHp67bw+yEhHqjaOWt3uunDCEgE6+ckk3jNmWu/2JowcaJh ZIc28gzPMQTPRr+bKm/X+Bn6GkbKQIIckVPwWvKbv7RaI8xqxZrd4m6jGwiX3tYYMSNI49L56h8 akFjclqSdu2sKUzNtYnNeCRjQVrMyGPQi862Eens6P6K8VJ6EfQbAwEaj0qwqwUn8i8bQb8/OJ1 IASPaL60AFqsfMYYYX1IwD0mdykLKKhYJQjKZcpBakJxjaCtLNt16nsAVSj/FSsTbTwvMwZ3prk 4hqIq3rq17kDweA== X-Developer-Key: i=bartosz.golaszewski@linaro.org; a=openpgp; fpr=169DEB6C0BC3C46013D2C79F11A72EA01471D772 From: Bartosz Golaszewski As the final step in adding official support for shared GPIOs, enable the previously added elements in core GPIO subsystem code. Set-up shared GPIOs when adding a GPIO chip, tear it down on removal and check if a GPIO descriptor looked up during the firmware-node stage is shared and fall-back to machine lookup in this case. Signed-off-by: Bartosz Golaszewski --- drivers/gpio/gpiolib.c | 50 +++++++++++++++++++++++++++++++++++++++++-----= ---- 1 file changed, 41 insertions(+), 9 deletions(-) diff --git a/drivers/gpio/gpiolib.c b/drivers/gpio/gpiolib.c index ba5df8a233fe75e16bae615f7f7c8591066c056e..03fd60e787fcf5846519fb2db9a= 701770ed15d6b 100644 --- a/drivers/gpio/gpiolib.c +++ b/drivers/gpio/gpiolib.c @@ -37,6 +37,7 @@ #include "gpiolib-acpi.h" #include "gpiolib-cdev.h" #include "gpiolib-of.h" +#include "gpiolib-shared.h" #include "gpiolib-swnode.h" #include "gpiolib-sysfs.h" #include "gpiolib.h" @@ -1200,6 +1201,10 @@ int gpiochip_add_data_with_key(struct gpio_chip *gc,= void *data, if (ret) goto err_remove_irqchip_mask; =20 + ret =3D gpio_device_setup_shared(gdev); + if (ret) + goto err_remove_irqchip; + /* * By first adding the chardev, and then adding the device, * we get a device node entry in sysfs under @@ -1211,10 +1216,13 @@ int gpiochip_add_data_with_key(struct gpio_chip *gc= , void *data, if (gpiolib_initialized) { ret =3D gpiochip_setup_dev(gdev); if (ret) - goto err_remove_irqchip; + goto err_teardown_shared; } + return 0; =20 +err_teardown_shared: + gpio_device_teardown_shared(gdev); err_remove_irqchip: gpiochip_irqchip_remove(gc); err_remove_irqchip_mask: @@ -1283,6 +1291,7 @@ void gpiochip_remove(struct gpio_chip *gc) /* Numb the device, cancelling all outstanding operations */ rcu_assign_pointer(gdev->chip, NULL); synchronize_srcu(&gdev->srcu); + gpio_device_teardown_shared(gdev); gpiochip_irqchip_remove(gc); acpi_gpiochip_remove(gc); of_gpiochip_remove(gc); @@ -4646,11 +4655,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"); @@ -4673,14 +4700,19 @@ struct gpio_desc *gpiod_find_and_request(struct dev= ice *consumer, return ERR_PTR(ret); =20 /* - * This happens when there are several consumers for - * the same GPIO line: we just return here without - * further initialization. It is a bit of a hack. - * This is necessary to support fixed regulators. + * This happens when there are several consumers for the same + * GPIO line: we just return here without further + * initialization. It's a hack introduced long ago to support + * fixed regulators. We now have a better solution with + * automated scanning where affected platforms just need to + * select the provided Kconfig option. * - * FIXME: Make this more sane and safe. + * FIXME: Remove the GPIOD_FLAGS_BIT_NONEXCLUSIVE flag after + * making sure all platforms use the new mechanism. */ - dev_info(consumer, "nonexclusive access to GPIO for %s\n", name); + dev_info(consumer, + "nonexclusive access to GPIO for %s, consider updating your code to us= ing gpio-shared-proxy\n", + name); return desc; } =20 --=20 2.48.1 From nobody Sat Feb 7 23:48:06 2026 Received: from mail-wm1-f47.google.com (mail-wm1-f47.google.com [209.85.128.47]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 19FD634A796 for ; Wed, 22 Oct 2025 13:11:14 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.128.47 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1761138678; cv=none; b=HXIRteJybqrT3Jn8xDC+KiXZhQu/wFFZ+mn1t5u1Q5rMauktiCOLKKE2UhG1aLT6nmQEPTHFngd+43MInEobZqf5javKJsptAIwDbM81bjjJ1S+qvIkZ8SYPtqRXe3CCl2YgIKZ/Jj1E3NEQSwlfdt+zwHurAHHVsgpgyKgWWN8= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1761138678; c=relaxed/simple; bh=o3i7hzZy+G5XVTT/nrasUIRd9dxxVmZhC6vwJZuaTAA=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=Y7GKl7LSFu1+VVLwnoMNrgB/igEvW+CqGyqHPhhv5L/ZkwXOH7d0QP7OOrQlEEQG7edV3UPo0KROUbKOkOK/eNez1xjGzsK3jeskyj1nHo/LEpwGCXlCW4iy/0T6MobNiR2rTvPAjySMej7PlUouGWUrv4FvujSx5NU4ro4+L64= 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=l2ueCF4X; arc=none smtp.client-ip=209.85.128.47 Authentication-Results: smtp.subspace.kernel.org; dmarc=none (p=none dis=none) header.from=bgdev.pl Authentication-Results: smtp.subspace.kernel.org; spf=none smtp.mailfrom=bgdev.pl Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=bgdev-pl.20230601.gappssmtp.com header.i=@bgdev-pl.20230601.gappssmtp.com header.b="l2ueCF4X" Received: by mail-wm1-f47.google.com with SMTP id 5b1f17b1804b1-4710022571cso58219775e9.3 for ; Wed, 22 Oct 2025 06:11:14 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=bgdev-pl.20230601.gappssmtp.com; s=20230601; t=1761138673; x=1761743473; 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=NmyJwyGotfh3JyXhmJS/1rlzs+tHyJOuYkq2PFxtZmQ=; b=l2ueCF4XM9Aqpc5JXNE5pziPjP4cP77Evs/POq4tQJMwgSUIY/ELByr+58FVS9THac huwrNH9XkVNwYUAG3i33KrQ4ozEJSZbQdoRcLPxrYp2HkEo+FZ7uuxQgfYRXnUe1wfBK uQ+Ik+ob8AzUkF8k4jeoE6xOrdo32IZR4WwlKkIWVgKs7qVykoTpnGV6RG/PZD7eRcpM 0Zw6JinzH2hgyrGP9MDRSSRxEJtPPVX35LOw4ZMqzbpZLIiyLiOGcii4NWf0B8EQTFJD InLWa/7VWiRLyWQe3L9sXa4zEAx4U0HHHLd1J03XQhvRadRrnFXR6no6ywU5/1p2dmkv vSnw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1761138673; x=1761743473; h=cc:to:in-reply-to:references:message-id:content-transfer-encoding :mime-version:subject:date:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=NmyJwyGotfh3JyXhmJS/1rlzs+tHyJOuYkq2PFxtZmQ=; b=dhWssU2kzHRFt9tmbM1HVzlKDRW2Tpmb07WflVlzAd53JyFn1Rap+rY6zHvC3p43bK HNaFHLPqiJYDVkA9Q9XUYgunIEAzSPbOf0pHtBzgghtlvDXzAqgIRcqiQv2yWv9lu6Pf Wd/Cn8QEjm+N6NhUPns2FxMf/kLQreFSkatxMC1+CTrP6Z3qNWVCwp2iCFR05xuEvd4N Gsrh+JIyPAElbhWOyyAjW1O3IDEl9gjZObUSy6R30Kk2D5nfSAhZ3lk69GdMYP8RoyFa 9RVqvlnWYiZYvHs+pWftVCrpoCbUJ7QhG96wtoIXgxcZuaGPZwiUclQIpouJd7FL2Bqg gnGQ== X-Forwarded-Encrypted: i=1; AJvYcCWkpgjIm0HbzS19YK67BgA7SKo6+vDVYwlfc42/KfHVpuFhh3t4BaT2vtaJK4EJgn/oIk3hCgCOn3Rxois=@vger.kernel.org X-Gm-Message-State: AOJu0Yy0+oxpnnW7zmLieZusIv3UtTFm+qf59Jspf2WcWtaZ6VMB6Kgv wx1jol1xJ5yVJRDrLHtDzTZ//J3B+ntX70UpDqDfZdYJLNLGG0xXRwYVlCzUaJ0KZ1c= X-Gm-Gg: ASbGnctvYPQI1w5xIMaZMcqQth6Qwxqq+UqF5Zqr5HpZ+4pGvN524WwNivx0KLTxQ7S 7bwf+Tw6iA1fEpXRvsCHMl/SP0M7CpvSt52arBATn2mt1u/AupvN8d7b2w9khHpiT6MEMSiVhPm Tt3HDhAfyhXkkTWqKyYMzcypxzRGEl+a5pWFx1xb5RVTIFEs9rmOCq3BDWr4yD8Un6UKzEjOGSo h9aIcAXPeQoqIaTDfNnZ/i4igKN/skZLWKfeIl8jg3AJVsB900sAuJG77mRz9vNzMesWNzEJu0q ryfsmoqkLXSRi0UHx1P/BsEruM+qNaKC+rs+whMR753P1x4Ck5K5xNfdB6VLlPbeh3kXGM4Dg8Y cbjAWbeapTZujmts8zQvxggrEI/qAjuW0MOo+7TDUmTcEkzeDvboMfWkLwDWexgk6ONC6EBc= X-Google-Smtp-Source: AGHT+IFvKb3JoyG866nslJyNC3Ibg/oUQ/wlCU6/03uxa7bXbKsZVrSqlRlb8S4Ya6isf5ldIVuivg== X-Received: by 2002:a05:600d:14:b0:46e:4705:4958 with SMTP id 5b1f17b1804b1-471179174f4mr126289245e9.30.1761138673264; Wed, 22 Oct 2025 06:11:13 -0700 (PDT) Received: from [127.0.1.1] ([2a01:cb1d:dc:7e00:69df:73af:f16a:eada]) by smtp.gmail.com with ESMTPSA id 5b1f17b1804b1-47496afd459sm38839905e9.1.2025.10.22.06.11.11 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 22 Oct 2025 06:11:11 -0700 (PDT) From: Bartosz Golaszewski Date: Wed, 22 Oct 2025 15:10:45 +0200 Subject: [PATCH v2 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: <20251022-gpio-shared-v2-6-d34aa1fbdf06@linaro.org> References: <20251022-gpio-shared-v2-0-d34aa1fbdf06@linaro.org> In-Reply-To: <20251022-gpio-shared-v2-0-d34aa1fbdf06@linaro.org> To: Kees Cook , Mika Westerberg , Dmitry Torokhov , Andrew Morton , Linus Walleij , Manivannan Sadhasivam , Rob Herring , Krzysztof Kozlowski , Conor Dooley , Saravana Kannan , Greg Kroah-Hartman , Andy Shevchenko , Bartosz Golaszewski , Catalin Marinas , Will Deacon , Srinivas Kandagatla , Liam Girdwood , Mark Brown , Jaroslav Kysela , Takashi Iwai Cc: linux-hardening@vger.kernel.org, linux-kernel@vger.kernel.org, linux-gpio@vger.kernel.org, linux-arm-kernel@lists.infradead.org, linux-sound@vger.kernel.org, linux-arm-msm@vger.kernel.org, Bartosz Golaszewski X-Mailer: b4 0.14.2 X-Developer-Signature: v=1; a=openpgp-sha256; l=4760; i=bartosz.golaszewski@linaro.org; h=from:subject:message-id; bh=x7L0RijU+LCdHfGCAJ/VkOYZp/t4v/DX9On78RPb0YU=; b=owEBbQKS/ZANAwAKARGnLqAUcddyAcsmYgBo+NfdZs8MgTMizrWDvDv1UjUZTogiIeLTWekA/ YC4FrScCIGJAjMEAAEKAB0WIQQWnetsC8PEYBPSx58Rpy6gFHHXcgUCaPjX3QAKCRARpy6gFHHX cnAgEADBzLwtXPh2XKMVjNVTb3+/+na90OoVl87WRHstD2bKhyf3X1zCGxWwdcpFH7ZAY3X5cj6 /QMO3st1TRPyuwvJjld52dtJWPYqkpxKokQOroUrZUNtkurk1CW87T3aGzO8lOZbo0Lfm23dQwO sBkrJTztEWsGyJiq6ofdmzamQhN1EVEQJRWC/c2QY1lozPK2lp5Egdi0Z0tlhxeqpA/phf9Ncw7 Qe8kksbK1r5OO4SyBZZxCe9gNQYH04PEzWsgCI5oT0pKIyaFaQXAtEhUI8S70m+77npYxr8Mzz0 xBzSAFPuVIYx3RLeQFPnpxMpT5XgGTzD4knJaa0ONGXTZGLYvUg7VJK2tmwb1bhL3aShR73MpDv MTeQjM7Ss/oksGzF5/Pt+VPnNBESFJ2cwYIuCP0S14CuOoqZwvMmrU4Afd8ZyS8CnQjfbzNkp/n abe0kCW+B8VEJMnXQiboWKlmEvmOSpmPFAlv8e/jNV8e/JV9stT4bXTjKxHtoQBjC1Df4Va/24w 0o/JgFDARBNyFVOM3GYNWuZjFv8lSd/Ux3+vFPnWEhyVDjDbAqoeZrJL3fbWfiCfZmlup58aZPA PzJmNLr/bcmpc/+f4I4gy+TNt7c88z+qB7fnIdOPkbYuTBDtkrGpHMutGANHANOxN3C7Pt+Uy1f 5DYXoQM9Pkhsz0Q== X-Developer-Key: i=bartosz.golaszewski@linaro.org; a=openpgp; fpr=169DEB6C0BC3C46013D2C79F11A72EA01471D772 From: Bartosz Golaszewski Provide an interface allowing consumers to check if a GPIO descriptor represents a GPIO that can potentially be shared by multiple consumers at the same time. This is exposed to allow subsystems that already work around the limitations of the current non-exclusive GPIO handling in some ways, to gradually convert to relying on the new shared GPIO feature of GPIOLIB. Extend the gpiolib-shared module to mark the GPIO shared proxy descriptors with a flag checked by the new interface. Signed-off-by: Bartosz Golaszewski Reviewed-by: Linus Walleij --- drivers/gpio/gpiolib-shared.c | 18 ++++++++++++++++++ drivers/gpio/gpiolib.c | 20 ++++++++++++++++++++ drivers/gpio/gpiolib.h | 1 + include/linux/gpio/consumer.h | 9 +++++++++ 4 files changed, 48 insertions(+) diff --git a/drivers/gpio/gpiolib-shared.c b/drivers/gpio/gpiolib-shared.c index d2087d0df4ab7bcd23d3736e341c0f57cd748af4..b5c33bccff0765eb940fedd5d67= 8c47a05f1a25d 100644 --- a/drivers/gpio/gpiolib-shared.c +++ b/drivers/gpio/gpiolib-shared.c @@ -309,6 +309,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 03fd60e787fcf5846519fb2db9a701770ed15d6b..d689065471a1269ac0671b964c6= 7670df5c95dd7 100644 --- a/drivers/gpio/gpiolib.c +++ b/drivers/gpio/gpiolib.c @@ -3984,6 +3984,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 ae9aa145ca055c08dad55a537567a27de57f7066..8deed8a7d1128f01f0696af040d= 06f5fe140c7f8 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 00df68c514051434e6fa67dc2307c6a8ce4ce3df..a8acb7c0b5af5066fd05e533468= fc28616c68d78 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); @@ -520,6 +522,13 @@ static inline int gpiod_set_consumer_name(struct gpio_= desc *desc, return -EINVAL; } =20 +static inline bool gpiod_is_shared(const struct gpio_desc *desc) +{ + /* GPIO can never have been requested */ + WARN_ON(desc); + return false; +} + static inline struct gpio_desc *gpio_to_desc(unsigned gpio) { return NULL; --=20 2.48.1 From nobody Sat Feb 7 23:48:06 2026 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 C8BC134B18A for ; Wed, 22 Oct 2025 13:11:17 +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=1761138679; cv=none; b=UE7Uw3aW8CaSQKZpeWpJpbh52sxZIA+HGKipfHlUuq6e2OCBPwLBGv1+kLB1XjIiTtkvmDUMlmWVHRQLE/IfDaGpK13KGpv1ZZoXUeYUw8MN63EBegv6SRzDvhIPXeMWmz8nmC/cthNNmPE2vuqqQSiOErPAqe9HLOP+Zo8hNCg= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1761138679; c=relaxed/simple; bh=qcX1d63axfEm3RBwV296f+6+sRglnyR7jSQ67K8y59Q=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=ZETH+YOWPCX+cC9ZhH0ym1zO0uYgvolY4Aq8TVv6E/rP8so652jX/NhevTfskOLwVIjbYKqFlVIrinYIY0TuuUAsl8Bryx1Ob45C275nKcYpxhJQ7T7dtXneFXSmrEfTrDj1+NJMW6xc2sWOmCWDvbxaNrs6CAm+v54iMXyGHKY= 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=e9bgORKN; 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="e9bgORKN" Received: by mail-wm1-f45.google.com with SMTP id 5b1f17b1804b1-471066cfc2aso20895185e9.0 for ; Wed, 22 Oct 2025 06:11:17 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=bgdev-pl.20230601.gappssmtp.com; s=20230601; t=1761138676; x=1761743476; darn=vger.kernel.org; h=cc:to:in-reply-to:references:message-id:content-transfer-encoding :mime-version:subject:date:from:from:to:cc:subject:date:message-id :reply-to; bh=ibo0NSWbl5C+bQQFmoxlAmjW8oHbuGgT0ysyiGqJH04=; b=e9bgORKNCvinL7GOYPu8YvUoJxoTl2TGNlE3olouBYpCj8UDZYpe50mTaaEIhMsdHx zgAgE3bththrbsAwdyfLI42nCYipcSIdpUXNye+DOPXbqsS8LMOWKMsjvZ4Gj+VhJJuo AYhfr7eP2G0a3d8xVqY9rNRxIph4adv45tjOK8d1oKM/uGvs5U03N5N0VHCkhGXhe9Bw /S5WppusOM1yuK+QfHmYLMM6LxZlSwpThS62/jv0W4EjFWOMCQNby2fERzbU/zgMTpyn npJf6sU8GVvLQXK/5S4KiChq8f5o2qToi6/IiMeu1513ZoeJxkJT1bqUXuUAlipaXUsR Oj8g== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1761138676; x=1761743476; h=cc:to:in-reply-to:references:message-id:content-transfer-encoding :mime-version:subject:date:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=ibo0NSWbl5C+bQQFmoxlAmjW8oHbuGgT0ysyiGqJH04=; b=fQk0i6LmVpZ7HLOfIXKq4kAAiDZ8w66eftwndZYF74X3ozA0s5GBewnv4AUOOJErpb fwx+MpRauDUxrc2n+/XsNtkZ3KGAN7m21PRqzSBQTIw3GoZWryfektt67709bWwQLfng +vtIx7HpnM/yvpRL2zdBFtbD0UDtKQPWkunb2eOkZnDgZSMv2TJywIlx96KYHkSjxarQ 3rUD87d/73NfGGyGDMcrxiROL31Ay4BxqwPg0Y71QWWPNhVwoZMMkJz6VgBgqmFODowf J0PjVhXh8xSVrub6krDdHMMf8i8u1tH/Qukd/Iw+ENmx6WxB/4zl9AGOoRBifCKPMhuR qbJQ== X-Forwarded-Encrypted: i=1; AJvYcCVODzTxaCCWsm2sYYMTdNYRMa90XDqq93R6+Y/MISWo8cdBl0ZA1xotztSinPys4mS/kODtTUwrXoOi80w=@vger.kernel.org X-Gm-Message-State: AOJu0Yxg7Kv+TwNUPXBXHqUHpp3i7LLgSFpErtC2xjbtbosz/bQ3Eh8f aY7fvQBJVpkQffgGfrHFk8VAQXTj1lHxZjVbEKao3TeZ+j3+KlshKrTK0lGmyow8cVw= X-Gm-Gg: ASbGncvQuvCuDTLJeDzg0m0ogBJFIeKoA2hACRwMSt9PIMIJzttyuU1x9jcJjw60v7G XVUjRzf4gkCTiPveENOnMGDEIkF9Zw9hF9YBLhnCDFl7ODYvKEhKA+4WgMS+ArH0WqNd/qTX1W1 NXfcKmxnaAZdjl+km898FFqb+dLoLJ+rRajfKaqkRId44NqINTuNh1ux7VnObTZ+AkWMgPn2Z7N xz1r/Xdy1o2UGQbr32JOOUTEjbcb+h5dsxRrSX+B3KZQqZ9nPs7hFYDW1udsMCBPCpEyIdlLs+l HGSXVEPQ+9pcyXz6Bd4xwSWvDYoaUb9u+wir5d++QsMeJtiSA+KADaDO3FiPpFkUYhdE8g5iybI DfB1Vu3BJw7tzjA9CdCDA1Q5gGh0q039FNDv9obWlDdAavOewWUoIXFKClZ1oim9dfcCi1zc= X-Google-Smtp-Source: AGHT+IF0wOtT5w+tdQQmrXZnXXSDYjp97opprFhrYP7Wm2xrNoUtmZ/FuBkt9NLdeFl+hYiIXGovig== X-Received: by 2002:a05:600c:6085:b0:471:133c:4b9a with SMTP id 5b1f17b1804b1-4711786c79emr179394635e9.6.1761138675738; Wed, 22 Oct 2025 06:11:15 -0700 (PDT) Received: from [127.0.1.1] ([2a01:cb1d:dc:7e00:69df:73af:f16a:eada]) by smtp.gmail.com with ESMTPSA id 5b1f17b1804b1-47496afd459sm38839905e9.1.2025.10.22.06.11.13 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 22 Oct 2025 06:11:14 -0700 (PDT) From: Bartosz Golaszewski Date: Wed, 22 Oct 2025 15:10:46 +0200 Subject: [PATCH v2 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: <20251022-gpio-shared-v2-7-d34aa1fbdf06@linaro.org> References: <20251022-gpio-shared-v2-0-d34aa1fbdf06@linaro.org> In-Reply-To: <20251022-gpio-shared-v2-0-d34aa1fbdf06@linaro.org> To: Kees Cook , Mika Westerberg , Dmitry Torokhov , Andrew Morton , Linus Walleij , Manivannan Sadhasivam , Rob Herring , Krzysztof Kozlowski , Conor Dooley , Saravana Kannan , Greg Kroah-Hartman , Andy Shevchenko , Bartosz Golaszewski , Catalin Marinas , Will Deacon , Srinivas Kandagatla , Liam Girdwood , Mark Brown , Jaroslav Kysela , Takashi Iwai Cc: linux-hardening@vger.kernel.org, linux-kernel@vger.kernel.org, linux-gpio@vger.kernel.org, linux-arm-kernel@lists.infradead.org, linux-sound@vger.kernel.org, linux-arm-msm@vger.kernel.org, Bartosz Golaszewski X-Mailer: b4 0.14.2 X-Developer-Signature: v=1; a=openpgp-sha256; l=735; i=bartosz.golaszewski@linaro.org; h=from:subject:message-id; bh=LQ6GmHpD/iWFySPYiWNs4nA4WFevXV0FDAv5KxrY5e0=; b=owEBbQKS/ZANAwAKARGnLqAUcddyAcsmYgBo+NfekSMiWGzrKtKuLqKr9X/aFL7erEPkinVg0 Ya0yCZDb8qJAjMEAAEKAB0WIQQWnetsC8PEYBPSx58Rpy6gFHHXcgUCaPjX3gAKCRARpy6gFHHX cgEvD/sF0UNAC5n2ObDj20Wt2u2qe866svdBJRyT7vFi324TFqRE3bSjbOk9y/3g6LFT/ehBXIn g5lxm2qJ147ZK9Sm3UfKI3Kvwqq1sBLnhdGtoihARXjAn+De38GcqhOl24nvHJlvM9tGkHnnxNN YGp6a8Meo66SYHnbicVDA6n3CuHl85/Jpr9pIgpE1xll9bGifkT1okSqdNiE99fbZMpvt6LRnxK xuKuyzK3N5G9ZKUB/l1WzvlsTJNqCtn98hSufn9wJ1C/kQjZGVjh05hyf/Ww5pY5Ko8ntxmwMVu XT0raHo2LULYRMGPBYbXxASf1rtF31mIDi3XbCa4Aqq1sfdZmyhuiu7ikz/4peZ4Ls3MctkBan1 PoFpHPK+X63q/Hui+iiIi7tiOrrLqQZmxyLyjCvlo04Z9IEUpp/ud5HmrpJEuc644DxLiknre+L C8/oJIZXPrMTpOvenMbanP06CADPW96Q4Xm6+eeL9j8/RvPVpkgwOi3LFJLfVUl5rswQjX2ODUV A+VhtQakOsX5i8Y/AU89XVDQExM28exRzPlc7qjo3j7O5s4cy3ZbzdlWBi68i1D5qmEJqXnC2WH bcq/Tv7Ul5b4jALao342Nt1r5rbCVZWQMqMTT8gaLmNjlS2rVvnKrWUfri+/WeiJhW1/rTAvX3V liFuFefP2GjBr9Q== X-Developer-Key: i=bartosz.golaszewski@linaro.org; a=openpgp; fpr=169DEB6C0BC3C46013D2C79F11A72EA01471D772 From: Bartosz Golaszewski Some qualcomm platforms use shared GPIOs. Enable support for them by selecting the Kconfig switch provided by GPIOLIB. Signed-off-by: Bartosz Golaszewski --- arch/arm64/Kconfig.platforms | 1 + 1 file changed, 1 insertion(+) diff --git a/arch/arm64/Kconfig.platforms b/arch/arm64/Kconfig.platforms index 13173795c43d4f28e2d47acc700f80a165d44671..3dbff0261f0add0516d8cb3fd0f= 29e277af94f20 100644 --- a/arch/arm64/Kconfig.platforms +++ b/arch/arm64/Kconfig.platforms @@ -316,6 +316,7 @@ config ARCH_QCOM select GPIOLIB select PINCTRL select HAVE_PWRCTRL if PCI + select HAVE_SHARED_GPIOS help This enables support for the ARMv8 based Qualcomm chipsets. =20 --=20 2.48.1 From nobody Sat Feb 7 23:48:06 2026 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 48F28347BA0 for ; Wed, 22 Oct 2025 13:11:19 +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=1761138685; cv=none; b=Qsszt+5v1MFdi5LbFfr4VRwxac5Nc+0JPgZ4AIK+JSEFk4Dze4AhCF6qO3CXVfkSvY1BH4tDfzMBfYOoz5BYhNlPk5UTTIwHI+gbUUpBV/tXxA7LIebZoCEzIiFrJeGub+Xm/Sknbb0OcpojlUHDmP6iAGxtWd8JlWjHEeBZgxg= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1761138685; c=relaxed/simple; bh=o3clotEVXCzqMxW1qJk3uiRPSq6aP6WSAmpPzr7h58A=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=Yx6OP0RuCdzulAydKnmDDnUWlRBlFi4VJLhGPtUX73tl+OxWHfksPzxpqPNRL+BFlJfysYd9JJfAb3oKnKqtryQMjCv2hM+5gF1Q5f7ToBge9OBwyYhn028YGZi8NfkgkVVLt0l4CLrkPeipvINyCiL+L+NwxbCtFfFps2GIbD0= 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=bH98ofeG; 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="bH98ofeG" Received: by mail-wm1-f50.google.com with SMTP id 5b1f17b1804b1-4711f3c386eso35808655e9.0 for ; Wed, 22 Oct 2025 06:11:19 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=bgdev-pl.20230601.gappssmtp.com; s=20230601; t=1761138678; x=1761743478; darn=vger.kernel.org; h=cc:to:in-reply-to:references:message-id:content-transfer-encoding :mime-version:subject:date:from:from:to:cc:subject:date:message-id :reply-to; bh=JSTA3g5ank1TH+h8Aobptwj96daqy8jbcBAobAq2Oqo=; b=bH98ofeGq2B5sIlsDhEpNKiEgLvnAByQsql+1Ix47/u/jivUYJEbsrT8P9YiFrTpEx 5QRFklFfg6HQYPlMSw0Jz0M3SQ+i3uW9UPM0eA+G6ez7L5KEGZ5rjPa6i8EG3LdZxV+/ Lxz2Ci1eiWgt7R8rovUwdXwMkRGaVArP7USx8CluvViXqXSM2fha7ds6mkkTSdpevI/B SBjTWf858h+7jTtF8sUeVz15kZKQ0gPuGwSDxS2Q6LRfH0rqs8/wNpSAprQHGWEL98lv MW+owMZqgXiO68kAH//wzUV5UnZeIphtmzeZxqYt3e/o2Jxi1gA3p5ky3CXjZWNAcMA6 z9Dg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1761138678; x=1761743478; h=cc:to:in-reply-to:references:message-id:content-transfer-encoding :mime-version:subject:date:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=JSTA3g5ank1TH+h8Aobptwj96daqy8jbcBAobAq2Oqo=; b=WLWLXG327W+/JMRECMZOJr3eCX+BOdivRDs06+FqJ+5lVf9WOYel2XD1m0LrRSzFeX qo2r5kDAz6OQtESA6PfjjriXCAU9q5ER9ZcwOrWcTDBcor1tNvGvaszpIHCcuu9FrnTt dkSBr9fZP+Gg86OjGX6la14dCAnHxPkWcQv0YLrzgymYBFo/GofDsKxLLpqmTb3rgcEC m+pYOPeBNbLU4aSgks91S7q+WGD8srMm5NwHLaYotMVYh7pllZsrWO0Yyo3LTtPb/itX AKGZQZpccidhMqXVqqo9WmOk2LSXDYBHexRRYi/RJkDEMVjM1XsMT+PUjTXUgvM62rMN GCbw== X-Forwarded-Encrypted: i=1; AJvYcCUMP5UFbumyDZ3gmmr3atdXRoGxIsxGd8l/NRLCtbq6FxKUvn8ewAVggBhuth/xQ+1LyAD+V32iLWPfi1U=@vger.kernel.org X-Gm-Message-State: AOJu0Yzwr4jQCKHldxzjyNhL0PjZUq4bWh1VbC4nu8AZ07bQHl00dBfx 94KwgEUHqjwlXcj4nmubsVCz83eUl1neVia0Z/3nLkEAl7VA+x1w0aiV+g/IlAdGPow= X-Gm-Gg: ASbGnctPe1ayTa6tahnlJ0XHepOKwM5Bl9P3pbwhLC4rEQljdJ+5EVhpA38Sb8zRzam HMp5sAq7Kl+Oqj5bpEVdurO13sfuYOHh1olIwKvwBmJl+whLyoJtJuCf00sZmvbslg8WRzgZtnV h9YZgrpgLMhsKHslhkgqW5CO2T1ZWyNXTRx2pbiw+kJch8aZR4Y/hIVqYG3ldnGMIj8jIfcWlCv 6ZfjXAIgMWHQbdrQ1aXw+O+4xCP82uUY82tBTBeWjPNU4q9xrgT5HYDBICp5kZ+//DDvEneoQJu nCGZi5bHcoYqs7VgsnvZDpXyhBfrtHllZ7sJzEMJJby3guMoWDY2JJbjipeg2xUzOrAMY2sZnq8 vwQNn01QPHMihinXGtfCc1J6XCTgUIWTRwW77ETl3mzi6+qfMXfLZmkBGcVfWMKeVLgi7vtQ= X-Google-Smtp-Source: AGHT+IFPbcXLAtn4sbFkYplsW0U9MyKC7XwA3JcXcQOZluMyTLcgHp4ST5MfcutgxyGiqz0u3cVNNQ== X-Received: by 2002:a05:600c:a214:b0:471:ff3:a7fe with SMTP id 5b1f17b1804b1-471179123b8mr105019195e9.19.1761138678192; Wed, 22 Oct 2025 06:11:18 -0700 (PDT) Received: from [127.0.1.1] ([2a01:cb1d:dc:7e00:69df:73af:f16a:eada]) by smtp.gmail.com with ESMTPSA id 5b1f17b1804b1-47496afd459sm38839905e9.1.2025.10.22.06.11.15 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 22 Oct 2025 06:11:16 -0700 (PDT) From: Bartosz Golaszewski Date: Wed, 22 Oct 2025 15:10:47 +0200 Subject: [PATCH v2 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: <20251022-gpio-shared-v2-8-d34aa1fbdf06@linaro.org> References: <20251022-gpio-shared-v2-0-d34aa1fbdf06@linaro.org> In-Reply-To: <20251022-gpio-shared-v2-0-d34aa1fbdf06@linaro.org> To: Kees Cook , Mika Westerberg , Dmitry Torokhov , Andrew Morton , Linus Walleij , Manivannan Sadhasivam , Rob Herring , Krzysztof Kozlowski , Conor Dooley , Saravana Kannan , Greg Kroah-Hartman , Andy Shevchenko , Bartosz Golaszewski , Catalin Marinas , Will Deacon , Srinivas Kandagatla , Liam Girdwood , Mark Brown , Jaroslav Kysela , Takashi Iwai Cc: linux-hardening@vger.kernel.org, linux-kernel@vger.kernel.org, linux-gpio@vger.kernel.org, linux-arm-kernel@lists.infradead.org, linux-sound@vger.kernel.org, linux-arm-msm@vger.kernel.org, Bartosz Golaszewski X-Mailer: b4 0.14.2 X-Developer-Signature: v=1; a=openpgp-sha256; l=937; i=bartosz.golaszewski@linaro.org; h=from:subject:message-id; bh=vspstOLquen8UYYEalfT4SF6xCukX3qfgdJchdoYapg=; b=owEBbQKS/ZANAwAKARGnLqAUcddyAcsmYgBo+NfeRZqOvOB01WUMzaKtGFbfDIcDIo9Al+qfC +wjKxE0T0eJAjMEAAEKAB0WIQQWnetsC8PEYBPSx58Rpy6gFHHXcgUCaPjX3gAKCRARpy6gFHHX cqOBD/wJGzpam5upjt4XFG3ZtnI76Qt73nTbQAr6FUYWgq99m4KBvN2kA12dfb4qlkwNn7EoUjW SRmIlbN0zVeIoKGUrYP1ZX2Td4/d5eE//J5BAx70ZFkCnbIe2cQQdyMR3Qml7oKKdtE63vg8dCr Qu5FHzCdTlgUfT2/2uIPdU9r6i0ALa5XvaEjLLC82mevOPG1gtrUf83JWiVqWWwZ6msRsyR8GY2 XrTb6OI6XEkj3q/1E0iIviuAujfBeq9T1Ownl5xR7pdIBs5WOa80hNH447+vcOFh7AzkfCBK3iX 6dwc9e7MuhS5qhlfytzC6kern1Q2LyAbPgbSF0K2lTcpStRr+TL0C5u+/v/u2dlWaiQV/5vgsY3 M38/d/+SMR9NIR6RIIk+gmsuODW5tcXiet+FSnoN/NdlEC6CgSZxjOwHiOrYi4WnmtXcBEdGzgE r5xh4lhOWKOX9bb3Om8wiUdg+R24dQXyNu8yvSMPq85qlKROmlzenKwAeuC2YAJy++X+TSWMIgj 4lglVWusNTJscQ4jiIfdA4WEfjPwEeFljCXRMAex66b/J+Id6R/Z2yCKTeEXey+5tirG4UwEmbN 6fQ70BxWL5mmJU+NhsjvDwKCH7yVfWqNhcvZptN3Ji+1XZMmeTXbss4HoAjdl2x6n0ko6/T6ydQ TFgFaXpvdEUEjSw== X-Developer-Key: i=bartosz.golaszewski@linaro.org; a=openpgp; fpr=169DEB6C0BC3C46013D2C79F11A72EA01471D772 From: Bartosz Golaszewski This driver is only used on Qualcomm platforms which now select HAVE_SHARED_GPIOS so this flag can be dropped. Signed-off-by: Bartosz Golaszewski Acked-by: Mark Brown --- sound/soc/codecs/wsa881x.c | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/sound/soc/codecs/wsa881x.c b/sound/soc/codecs/wsa881x.c index 636e59abc3772fc0b333873a329b65f4213c3ef3..92a1e3bb8371e178571a6c1ed6f= 1185fe6c2e757 100644 --- a/sound/soc/codecs/wsa881x.c +++ b/sound/soc/codecs/wsa881x.c @@ -1112,8 +1112,7 @@ static int wsa881x_probe(struct sdw_slave *pdev, if (!wsa881x) return -ENOMEM; =20 - wsa881x->sd_n =3D devm_gpiod_get_optional(dev, "powerdown", - GPIOD_FLAGS_BIT_NONEXCLUSIVE); + wsa881x->sd_n =3D devm_gpiod_get_optional(dev, "powerdown", 0); if (IS_ERR(wsa881x->sd_n)) return dev_err_probe(dev, PTR_ERR(wsa881x->sd_n), "Shutdown Control GPIO not found\n"); --=20 2.48.1 From nobody Sat Feb 7 23:48:06 2026 Received: from mail-wm1-f53.google.com (mail-wm1-f53.google.com [209.85.128.53]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 17E6B34B41B for ; Wed, 22 Oct 2025 13:11:21 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.128.53 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1761138685; cv=none; b=lAn1ge8RLAwgrMqyGy2ZCqbA820mzIbisOIXj4sUOGda+YCvToc5BgTxXRJ0TLWWOSwuy+TVe3wdsURnRdjPQK3k+vPu5q22K5YKjClKLeheR+76EcrGyiGHeC3Y/Qnt402B+RebqExwsW0KNZuI3pXMsP3GmHcUjlExBeTTTWE= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1761138685; c=relaxed/simple; bh=kA7iX9loqcR1iPNQOHLnQ9pDOo+AVwSl3LLk/F4br8U=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=NFEPqSpH8ZGzLaxu0Lp2hswbKc8LfU1tmFdfANEHtnuEeVaTc4rCm1QWJTwIM7fDdVUWrW+zabVcDMrg7WRx3QMmi8lyu9sKdK/o2TVPzrR6euErAEMUHJahfHS0MAh7q2CWd5AmEdXEdAX4z5FLH8Dt9irHnBw9qIbgu7BK/f8= 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=GVW4ye2X; arc=none smtp.client-ip=209.85.128.53 Authentication-Results: smtp.subspace.kernel.org; dmarc=none (p=none dis=none) header.from=bgdev.pl Authentication-Results: smtp.subspace.kernel.org; spf=none smtp.mailfrom=bgdev.pl Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=bgdev-pl.20230601.gappssmtp.com header.i=@bgdev-pl.20230601.gappssmtp.com header.b="GVW4ye2X" Received: by mail-wm1-f53.google.com with SMTP id 5b1f17b1804b1-471131d6121so52267585e9.1 for ; Wed, 22 Oct 2025 06:11:21 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=bgdev-pl.20230601.gappssmtp.com; s=20230601; t=1761138680; x=1761743480; darn=vger.kernel.org; h=cc:to:in-reply-to:references:message-id:content-transfer-encoding :mime-version:subject:date:from:from:to:cc:subject:date:message-id :reply-to; bh=ndMaJDazpE5vfGfuGA/DbEp6kihBYbJYnxWQMZaUODQ=; b=GVW4ye2XC2mSzzm7rrhjJ+qKEEFXY+9D1iIrKlTJCLZ9F/JF+2asbuAevXxhHcWerU RpenGia5TNlCQZQuyyVZUksr/gvidtG2zIQf9avrQYL4+cMX21tJRO1lPLt6kjycs5zf NiFyQDitVvNsaMvvHk7FcYq6K+kAWWx/Dbw5FpG5uU3BMrv3YeXA179M9e3OAIyTge3w BqTbxh6JCNKGwbhjzbaZWTgJptGX+9SJZZkz8p9o5GxjFSnvPxruvrLQhta+TsBviTzq A9iAWInHFFIgR7sC9eJExGS+rzDV2IeOnUq3uTQHPfXZ1ajuvx8jCZ9djwhy2S1DYjrj 93Tg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1761138680; x=1761743480; h=cc:to:in-reply-to:references:message-id:content-transfer-encoding :mime-version:subject:date:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=ndMaJDazpE5vfGfuGA/DbEp6kihBYbJYnxWQMZaUODQ=; b=TLwgh1lxB2OY+llldj/Xp7y0zZyGJ9XKEnJKifKLLG6emRc0AeONRB3y27JCkHIiQu 0nOIQcvPflOSQxgnxIBbKo4nJDKyb5kkU6pPc3H7U6x3g8+EjtMdO5HDnvDxcLBd3exX GNIO8cxcM3hjc2TMbRRRJu+c2nYuW4kICYAyuuu0nXokmBIA/EPqbx/8/S1YRoxJ0dYH hHz1gxM7j/YnGWo8kN3XH+wu3fQOtEiQR7ozMG+b3NFPzkipgij3CqSwI3plPFfK3ojG cikMoCEJG04aNwh1h3cwptlorlrkupNDgJL67nBaEwN40A9Oii4wvWfoTphw8C3ugo38 0OAg== X-Forwarded-Encrypted: i=1; AJvYcCX7rSPG5wM405b5v0jt/JaQVyORcEa4cTU/+TGblBY1NAFTCrJHV5tzfDWzWGFPNTrwXe51OnqncLGBAAE=@vger.kernel.org X-Gm-Message-State: AOJu0YxAxkq4QX9p2H4pFSNE22FA74K2JN2BEPEQ+X4boQwsACVlnkVn X0Kv5jbOK40HLp6mcO0KmKjRJefo56k5CZAeClXTcqLgx9Xqji5Tomr/SMsOG73Q/ng= X-Gm-Gg: ASbGncuA1hdBtOvj7VzbbmTHNmRxVVnKKtfBnKAwMatfo72Fhnil8XU10vkHtQyM/VK SM6UKaAG0poZh7pflGHb38Qe7Yaq+jxVX1kj6zi+4hht48Bovfuq/0DcLnn6rKPXOebu/OyYn3w NDD40Wm2AZiX2Cq5zoGaENtlUyPpvO8E6MZWgV8rJpeIJ6nChq5PZ2U1eusBM4DtnO5U+aQEb1q gvb2MuTtXIC12T/piDyiABrnamv1EjPtRgbb1nueit/X/3ma69/P3fmDleEAIz1ZpC5soqfEjx9 m5vivaYhhNMY6FDJXBkR9CnBHyXxfnUY0MZU9IFqhXUgRACEPA/jkS6HdAGHaGRIhha+mP8gE3K lE8WrNSZe3aM0dfuhMh2w8P69K4Z/2QmZbWO+BbYTw3O55dvA5XapXF0BPalvARP2RvEu9iU= X-Google-Smtp-Source: AGHT+IElmfoCM4Q6owceAuIC32Swd+WBqF/ju4yk1O7IMXyO8uZfHXXvVXon02N5YX5wAalBpK6E0w== X-Received: by 2002:a05:600c:820b:b0:46e:27fb:17f0 with SMTP id 5b1f17b1804b1-47117877244mr152930715e9.9.1761138680082; Wed, 22 Oct 2025 06:11:20 -0700 (PDT) Received: from [127.0.1.1] ([2a01:cb1d:dc:7e00:69df:73af:f16a:eada]) by smtp.gmail.com with ESMTPSA id 5b1f17b1804b1-47496afd459sm38839905e9.1.2025.10.22.06.11.18 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 22 Oct 2025 06:11:19 -0700 (PDT) From: Bartosz Golaszewski Date: Wed, 22 Oct 2025 15:10:48 +0200 Subject: [PATCH v2 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: <20251022-gpio-shared-v2-9-d34aa1fbdf06@linaro.org> References: <20251022-gpio-shared-v2-0-d34aa1fbdf06@linaro.org> In-Reply-To: <20251022-gpio-shared-v2-0-d34aa1fbdf06@linaro.org> To: Kees Cook , Mika Westerberg , Dmitry Torokhov , Andrew Morton , Linus Walleij , Manivannan Sadhasivam , Rob Herring , Krzysztof Kozlowski , Conor Dooley , Saravana Kannan , Greg Kroah-Hartman , Andy Shevchenko , Bartosz Golaszewski , Catalin Marinas , Will Deacon , Srinivas Kandagatla , Liam Girdwood , Mark Brown , Jaroslav Kysela , Takashi Iwai Cc: linux-hardening@vger.kernel.org, linux-kernel@vger.kernel.org, linux-gpio@vger.kernel.org, linux-arm-kernel@lists.infradead.org, linux-sound@vger.kernel.org, linux-arm-msm@vger.kernel.org, Bartosz Golaszewski X-Mailer: b4 0.14.2 X-Developer-Signature: v=1; a=openpgp-sha256; l=1242; i=bartosz.golaszewski@linaro.org; h=from:subject:message-id; bh=xxM5DFs0HrWkdhU2lVlfFzKEyxjnJBr+LeYHk9Z5T9I=; b=owEBbQKS/ZANAwAKARGnLqAUcddyAcsmYgBo+NfewAfk5p+4oeOvjAnI585CCMJu5zdsTl5su CQCI6kaATOJAjMEAAEKAB0WIQQWnetsC8PEYBPSx58Rpy6gFHHXcgUCaPjX3gAKCRARpy6gFHHX cm3nD/9X6poJlB7hW4tB328EYqSDhizysWMNuFzzrMAB/gZ/dCtlUIbLV2FGSN4/hqWPj9FLVYa EfjcmFjHENOOZkS30hb0L5xxn1mh/rjIAWHwi3pbleTnKTDUoCF4W0wJ/Zs6ckL9JzdcWHVuuMA Az5VbXNST9iwIAUxWYdmAeAZ2AcD13/pqNrkGvH9uqEwQ3e+wEmMY512+R8xKRhlHPRJwhTR8dL 5onGyAoPZdHP3Ob+9N9Hlxc4WyTB8rVa83OTlpu7Tag7fbqhRXzngDxUPwYsvABWFvWcdIg8IYC k42uNeJy0KNjseRxvzZxC1pyACVME7kz4ig6TJOmGVyfMCenQJ78AeaIqNIGlnKqr3viJE2kxzm UevcSl/ZfjTeBVfrRSgC5+3JzKpgYOX7mVPsxyrfPWh74V/Zq4Ba2Pjxbe7Ay4xY3aK+zTbjWrs Z58p+1vzp64cUQ+Rqm7Mh8U9+v4gMcbBexYEZFt1g9pqhawriddU5vyYGB724c1Qe49WoWGfae/ mArKavWc7ccOhUfWgffapFXIglUnrG/NtQcJszys7vV+yPa+djWNZjQ94nRuNhU++rtbmNoDPYK 77Gqebezf9XhV9ixSvIGqf6I1zHHkROLC5eYTZy6EdG9Saxw8sj7arI4mkuQke0mNuh060xP4OE zX/Whv3fFll6glA== X-Developer-Key: i=bartosz.golaszewski@linaro.org; a=openpgp; fpr=169DEB6C0BC3C46013D2C79F11A72EA01471D772 From: Bartosz Golaszewski This driver is only used on Qualcomm platforms which now select HAVE_SHARED_GPIOS so this flag can be dropped. Signed-off-by: Bartosz Golaszewski Acked-by: Mark Brown --- sound/soc/codecs/wsa883x.c | 7 ++----- 1 file changed, 2 insertions(+), 5 deletions(-) diff --git a/sound/soc/codecs/wsa883x.c b/sound/soc/codecs/wsa883x.c index ca4520ade79aa2c9377449e29cdd33e9e8dd28c5..ba60b4de6cab7740cd8aa70c89f= 6e03e1dc2dd12 100644 --- a/sound/soc/codecs/wsa883x.c +++ b/sound/soc/codecs/wsa883x.c @@ -1572,13 +1572,10 @@ static int wsa883x_get_reset(struct device *dev, st= ruct wsa883x_priv *wsa883x) if (IS_ERR(wsa883x->sd_reset)) return dev_err_probe(dev, PTR_ERR(wsa883x->sd_reset), "Failed to get reset\n"); - /* - * if sd_reset: NULL, so use the backwards compatible way for powerdown-g= pios, - * which does not handle sharing GPIO properly. - */ + + /* if sd_reset: NULL, so use the backwards compatible way for powerdown-= gpios */ if (!wsa883x->sd_reset) { wsa883x->sd_n =3D devm_gpiod_get_optional(dev, "powerdown", - GPIOD_FLAGS_BIT_NONEXCLUSIVE | GPIOD_OUT_HIGH); if (IS_ERR(wsa883x->sd_n)) return dev_err_probe(dev, PTR_ERR(wsa883x->sd_n), --=20 2.48.1 From nobody Sat Feb 7 23:48:06 2026 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 269AC34B436 for ; Wed, 22 Oct 2025 13:11:24 +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=1761138686; cv=none; b=Ji6ldcKYwSW44nlineNYHRrmMxK7kMUOe6J9uLqA7ae76mQDz3dd2itGTTs8pXR16Iy+nMwCxM90j+SNSxF8UwJdfNYXk2/SLX3IzglVgsxYA78maEjYzinrzdhNbtqMo6BfAO5jsDIoVs0QvmJkC0Gm2atxXN6Zu8JESaw+8MU= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1761138686; c=relaxed/simple; bh=stH3r1LHkClCkcDML8lbPe+sizlONl6NhOJhh9xR7lY=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=i1t7WJLoZ1k5kQkvjZA8RTtuHK2ZHdonQQgluuSReCj92DkwaYEW8rMOUcQSZCFP/flZWOBxu6UDTQusIvA8gh2pnTy2ogPeQU4RTTPldA5SKHZgakuh2xtD0COgUidMrsi+XeINL3jugG/Rph5py2vujFw7338D7cA2QcpxyGE= 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=GtwNNOqd; 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="GtwNNOqd" Received: by mail-wm1-f42.google.com with SMTP id 5b1f17b1804b1-4710ff3ae81so25375045e9.0 for ; Wed, 22 Oct 2025 06:11:23 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=bgdev-pl.20230601.gappssmtp.com; s=20230601; t=1761138682; x=1761743482; 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=KIoKmjIInajLiemN3aTwTX5GXSgnREsQmJKoJ1Pkspk=; b=GtwNNOqd+3jlSwKgIEOyDgmxAS5B8M+Rj3gvNzrDFgX049wlW2V92ERVsdPNzxF9Ak DUTwcKKhVxvBfaUl9RPdBLz2ucR3H9pTuqUvyMN1xy4tMcp0P9kgrGmd1GptSg5kKhcb 1faAHMOPEPRDEpNMsoyWhvUsM8tUT/+k/znpp19r22mJLHeu5SUh3nRXwvT+2x2CXpgv FKA/3IkGa//zx2cARzzdRFoYXFofUEdf7N5vJOJ5BT00i/vUIbVwh8biN08Tn6xa4faY tAwm+d5ylHAxpiOxxAfsMlvaAEgk38zanr3ZOTIT2mX+AuTQ4Vpqdbf3b7ExxtonFA1W aGrQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1761138682; x=1761743482; h=cc:to:in-reply-to:references:message-id:content-transfer-encoding :mime-version:subject:date:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=KIoKmjIInajLiemN3aTwTX5GXSgnREsQmJKoJ1Pkspk=; b=AssNF5oEtX4i+GpAuBO05ztbmJvlHGCWAtOBlmJ98FGOQa8aSO3bC64qVHsrfDXuLP 2pjYF/nsOQ5FqX0H+LxwTgElInfzc21SHp/Nx98VGuhtMTvlJhdULmY8JOWwg7e3Q0sc TZGJUZPM4D3tpztt1CeodQzOVz7VH+JRJYgMgbC1p1xQKi2/j1EEB6bXF9ba6w3qYhOx W6i6tJYAXtDJwm048I552FtzoUo1ux2XOrc3/A3Ww78OFt+8SVeJKTmFY3c0oYBhSHsQ 7PeAug7uk2tIk7zDk/DtbjzGCZ/WEeOclis56PaAixhMqiyG4UD3a6BEPcIiyC1F4ggh jKyA== X-Forwarded-Encrypted: i=1; AJvYcCWdtgUByFlOlukni634DYE6PqGTgVnGItqUFPk686d5uGMZ0+9/kDNO2DMnZVLOoVnTYlw/YLlmNJAQEgk=@vger.kernel.org X-Gm-Message-State: AOJu0Yz9GIgS9Kc7IyS9ukFKY7E+HM5f80S8jNudACBIWD2Ag66zzb0Z cK6dW9xLwWDHig0feFh0aa0zX3/jimxMOfctR7T0T9ER92K7fMrzeINO2fX//2byT5M= X-Gm-Gg: ASbGncvWb3NtaOMzTnch1QVZYfM2OPuySkiqHVdUe85J+b4GjfabY5eKDqF8TnxZ1M2 ZPgTFfKQFCV9L6j21eLJND5XFe/UHjRFJTsbPo3x3V+lgdf9+W6yPlt+MRuNnciYRhIqcn7YOsr sqQp5inIknErLzMA5s9NfdPPd7JXEnEHGz9yXj0mpFIHLHGP9V4+kzbuAlVuW9wY/mK1IxCH2O2 +xz0y1JFF1rhvmVvyQ2KXdyQspln3xAPRBMxystrfhbFSXN/rKjebm9zRXmcErZDJwp3iu8wCIH RAIoVr98s/VJ4psyc2qkueG+aqPRMzvqlq439eVjZWNZ17l7yTqM42Utsq80BEMwDym1mMzK3C2 d7p7OURtS8hZWWyS6gEtCSF+sJ2YqT74ZlQ4WToFuRviSulL1VkBhN18acCLR6sS87SG6fQY2F2 m4gXHREA== X-Google-Smtp-Source: AGHT+IGkIuCyg+IuvK9C8PoKW8hm0lv3AC2LKI6qqGW0oK7q5GOxpXH1DI2XWiXLmBBfGx1o6tVduA== X-Received: by 2002:a05:600c:3b8d:b0:46e:4883:27d with SMTP id 5b1f17b1804b1-4711791c8d3mr166553265e9.30.1761138682075; Wed, 22 Oct 2025 06:11:22 -0700 (PDT) Received: from [127.0.1.1] ([2a01:cb1d:dc:7e00:69df:73af:f16a:eada]) by smtp.gmail.com with ESMTPSA id 5b1f17b1804b1-47496afd459sm38839905e9.1.2025.10.22.06.11.20 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 22 Oct 2025 06:11:21 -0700 (PDT) From: Bartosz Golaszewski Date: Wed, 22 Oct 2025 15:10:49 +0200 Subject: [PATCH v2 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: <20251022-gpio-shared-v2-10-d34aa1fbdf06@linaro.org> References: <20251022-gpio-shared-v2-0-d34aa1fbdf06@linaro.org> In-Reply-To: <20251022-gpio-shared-v2-0-d34aa1fbdf06@linaro.org> To: Kees Cook , Mika Westerberg , Dmitry Torokhov , Andrew Morton , Linus Walleij , Manivannan Sadhasivam , Rob Herring , Krzysztof Kozlowski , Conor Dooley , Saravana Kannan , Greg Kroah-Hartman , Andy Shevchenko , Bartosz Golaszewski , Catalin Marinas , Will Deacon , Srinivas Kandagatla , Liam Girdwood , Mark Brown , Jaroslav Kysela , Takashi Iwai Cc: linux-hardening@vger.kernel.org, linux-kernel@vger.kernel.org, linux-gpio@vger.kernel.org, linux-arm-kernel@lists.infradead.org, linux-sound@vger.kernel.org, linux-arm-msm@vger.kernel.org, Bartosz Golaszewski X-Mailer: b4 0.14.2 X-Developer-Signature: v=1; a=openpgp-sha256; l=1358; i=bartosz.golaszewski@linaro.org; h=from:subject:message-id; bh=p+y5IQEHjJOnxni5Zye5YZtGuUrzZOARpYGAZB998dI=; b=owEBbQKS/ZANAwAKARGnLqAUcddyAcsmYgBo+Nfe/WgJn3MUlv6tip0kIveOZg897ohp1tW6c islxAr8UxuJAjMEAAEKAB0WIQQWnetsC8PEYBPSx58Rpy6gFHHXcgUCaPjX3gAKCRARpy6gFHHX ckM8D/9Wzn/ftmZoRgjjTg5RZ1xRGR72VM20yOSyWEGtCSNeu4uUvBMNAdArlUONgpBYOFuCQ6f jxeo2x6+b3i0y/TKIIqp8XOebUFaChUTpW4V2aTOTzZvTL9CQWh7zsEHSztQvU9oHI+7XxP8KMW 9CY/L3iA8HVGuidSKPr780WTf1ctlM73GpwS8DZHS/+4f9kx8503W6W622tEi7x+fNx7TMYJnE1 8SkUCFoyxWoLyDmWJFr4Y9uXOrBzTTdTf0h6dGmUMoAVAYCQx90fRDcywibndcFyxTUs/XULCVl WcQzccUha2IfGjR+TpqQW/LtoW8xc7Vjig9winnhfWlIrLu0ddM0Xy3AjcWQGeiHoIGUGYy+vi8 gbRAq4h6J5vlyLsZIgr+4Q+AgPz6xZtpNyVc8hSkFHVQITKHY+xY9gRPIaptn0fMtoCSE7WslZ+ 9d7gHhQrdmlUDrJI68PPaPDaWumjqblocdZYLUS3nxddlkaOEzremAVAmSg2BK6TDEIBagmde57 lz3x7gKQp1EHI5GrfRSyIHKSkVKyTDnYFAumAYlYaVLc0UBrIvJPqQxUNkn2GGTWLOVC8qb/sgN +yauMt1Nu2ItKQTye6/6dBoSixx98QV5zlqOqM0MICJlNSyqWLbPU0uV/Xq2uI236ar5Lzwo/ie jAmXnk1wKw3Geaw== 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. Signed-off-by: Bartosz Golaszewski Acked-by: Mark Brown --- drivers/regulator/core.c | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/drivers/regulator/core.c b/drivers/regulator/core.c index dd7b10e768c06c83d2a4fb5dfd0fce8d796c9185..f9690f0689fda85123d07967f3c= 87105829e330c 100644 --- a/drivers/regulator/core.c +++ b/drivers/regulator/core.c @@ -2616,6 +2616,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"); @@ -2628,6 +2635,7 @@ static int regulator_ena_gpio_request(struct regulato= r_dev *rdev, return -ENOMEM; } =20 +skip_compare: pin =3D new_pin; new_pin =3D NULL; =20 --=20 2.48.1