From nobody Thu Oct 2 22:48:45 2025 Received: from mail-wm1-f41.google.com (mail-wm1-f41.google.com [209.85.128.41]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 0FFAA31CA57 for ; Tue, 9 Sep 2025 12:28:50 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.128.41 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1757420934; cv=none; b=dlybuXT2da3KEyWX3+i4kfVg/Dj4jQeqS64rDf5f39IrLRQU9w6UvOHqjzfpuugsEEK4nx2t8oS8acd7/9U4jp/PEc+32yipdKpBkePkFYwQaKEMM6t8uyDO5pobIQkhSAhaR41TNP/kE/zYXJRvetkgSjyW5jrtq+OTn1EuNeU= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1757420934; c=relaxed/simple; bh=ezEJnI3SwZsre2ee+xoZMAwqvzODmNkSeY7tjhGHAFU=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:To:Cc; b=Z5mQygUpRmH6wJnt+KZK0KxnMoXW+Dtx+Cm6i0gVNyHHHSSj64b/AiS8zgDoHEBuC2gEC8nbOiaVQhLqRYbAkDGBKkiWYbo+qSLw4wRZGOnx0V9DpTcBzEYK7lQ5OIQi/pe7JiIc2Abghmg5e8wgt19ixWwP4voOWNqS/8vkjUo= 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=Gw2G2OzH; arc=none smtp.client-ip=209.85.128.41 Authentication-Results: smtp.subspace.kernel.org; dmarc=none (p=none dis=none) header.from=bgdev.pl Authentication-Results: smtp.subspace.kernel.org; spf=none smtp.mailfrom=bgdev.pl Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=bgdev-pl.20230601.gappssmtp.com header.i=@bgdev-pl.20230601.gappssmtp.com header.b="Gw2G2OzH" Received: by mail-wm1-f41.google.com with SMTP id 5b1f17b1804b1-45de56a042dso15557635e9.3 for ; Tue, 09 Sep 2025 05:28:50 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=bgdev-pl.20230601.gappssmtp.com; s=20230601; t=1757420929; x=1758025729; darn=vger.kernel.org; h=cc:to:message-id:content-transfer-encoding:mime-version:subject :date:from:from:to:cc:subject:date:message-id:reply-to; bh=qb5FRnhlRCoQ3+qlFKt5O0IjptZI1+S2TMCDEjTQCE4=; b=Gw2G2OzHKXQjZwtDH9quxOmRaNaNizB4LJ5GqiIbig5wyHBeXY4HnkYAkAnCEpXOro UJ+dKyEfwjSKTwzF23JNBrJn64h70RZcR0a65GLZ/7GRpEVL6ffgFnoYsdLEjlK8VDd2 r1pMooNcvIiDiCU2yrGFH2gdfYMHIghAuMz6XteSX4B1SYNfft7aVf+TIaJW58P4XECk ALCZj6XErYStO8CWQTL6h35s/Vo+t1sgoxSq/i3FumiN17A4fQcC/IdUEBQq4ahYaGtr boPSaYrjn6b12XeHDL6IfVMatSnzjvOA+qNEPCxYtrp6Xiuk4FAi3SMqbWEF3yxONvV8 uORw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1757420929; x=1758025729; h=cc:to:message-id:content-transfer-encoding:mime-version:subject :date:from:x-gm-message-state:from:to:cc:subject:date:message-id :reply-to; bh=qb5FRnhlRCoQ3+qlFKt5O0IjptZI1+S2TMCDEjTQCE4=; b=IJY0m81JTeXWFBgEZlrgRO/hqGOe3vNIZi8h+5pVagpg9ZjeROAeaKepbb/DY1cNux rFrHiMuKJ4LuZ9slJXUF2EtYPSqm5qU4BirfkMufEHI8LEK7rRhdfLYm4kqoihpzSIVp abCszZ6FbypFy/E8qLGMERRAzAjIV57HkYPJ2winzmHl3tXthBbmXAxiq/raPeH3HMlC 2jH/bz3aJhkSyUWpl4IfoOopqEO58Kis4e8HiyyFr1HRiUV9+9w3nogShKMCwPd8Ymww Ig1/qzLXrXYtmQdf9VkITCBUYFgv4ivxmmaOdh6o/bVq6q+3gokG9LgqUyOfnzuoe5zO I1wg== X-Forwarded-Encrypted: i=1; AJvYcCXOIhCXoXw2n8w5w7ZUaZW1L1rSuICZHlKm9cjheqXcB/Qzh7aGcY0UcSTgL3voGx67IbJBzXlON3649bc=@vger.kernel.org X-Gm-Message-State: AOJu0YzsvhWgZ05FBqJC2y4Dy71TdVIQmhu3J+KySRLi6AzrliK5VmaK /GfYOVRa+C9/z5ebwCElExCT2OBx4rqNqFftw1X+MT+DZ9EG81qJDB00NGe/OOOFMSNsk/ccqxm vQNo5 X-Gm-Gg: ASbGncuN14McgaCo/xN/sDvAo+pmNb9KqgRbwuayAjG+CJ4yGQlq3+bhg9IKxkaYhfc 691O+ohHLfWoIAmCsVWD3MHtgPBmOTEexU4G+itV5sYLyPF9aUL1LoAU/R1ry34Nmqh3J7NB+Oe YN58n5f8YoafapDHcM4PH3ZbIE1lhR7Dzy/vqBog1dScvtbRVfs2DJ6BvNiKILgh9MzuddSiQ/h Qb4Kij4OSo0eKAlMzrpPNAFujxQy6w2a7nLaZBqZlo34ooe4zvRm5UV0SACeU2LBR0F8Zyseo6f /pSSFgOG+C6vO9mL9oJzxmnRH4l40SD/qaq6PClAwBrVqgPh4kiXKcMoAOW5f/0NnHlAEn+9oIe vWrPQYpn48kJBEj/jS8d6bNxQ4GlL X-Google-Smtp-Source: AGHT+IElJ0tENtrH0HdLsHJk/FjxEHiEF7YjHkdnEYHJUj/r/XeOuRddtns+wip00O9AsYOb+/D+hw== X-Received: by 2002:a05:600c:1993:b0:45d:db2a:ce30 with SMTP id 5b1f17b1804b1-45ddde0d828mr100996465e9.0.1757420928729; Tue, 09 Sep 2025 05:28:48 -0700 (PDT) Received: from [127.0.1.1] ([2a01:cb1d:dc:7e00:c1ee:7be9:3ebb:6cc0]) by smtp.gmail.com with ESMTPSA id 5b1f17b1804b1-45dd3aadbcesm213049775e9.17.2025.09.09.05.28.47 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Tue, 09 Sep 2025 05:28:48 -0700 (PDT) From: Bartosz Golaszewski Date: Tue, 09 Sep 2025 14:28:43 +0200 Subject: [PATCH] gpiolib: add a common prefix to GPIO descriptor flags 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: <20250909-rename-gpio-flags-v1-1-bda208a40856@linaro.org> X-B4-Tracking: v=1; b=H4sIAHodwGgC/x3MQQqAIBBA0avIrBuwwMquEi2sRhsokxEiiO6et HyL/x/IJEwZBvWA0MWZz1hQVwqWzcVAyGsxNLox2mqLQtEdhCHxiX53IaOxvnfd7Fu9GihdEvJ 8/89xet8P4wncdGMAAAA= X-Change-ID: 20250909-rename-gpio-flags-59f8a7bf60d5 To: Bartosz Golaszewski , Kent Gibson , Linus Walleij Cc: linux-gpio@vger.kernel.org, linux-kernel@vger.kernel.org, Bartosz Golaszewski X-Mailer: b4 0.14.2 X-Developer-Signature: v=1; a=openpgp-sha256; l=40092; i=bartosz.golaszewski@linaro.org; h=from:subject:message-id; bh=f1N5EW/6KDdp2QYMBemD7QhTTzeeqxftz41o9qbYAQg=; b=owEBbQKS/ZANAwAKARGnLqAUcddyAcsmYgBowB1/lLWLmZpa1FfilW+88/tNNePx76oOBJHaY 9vYUBf2+26JAjMEAAEKAB0WIQQWnetsC8PEYBPSx58Rpy6gFHHXcgUCaMAdfwAKCRARpy6gFHHX co8WD/4q/EGUzKCoKN4Dqn9arqbROgadfcuthkJi/PLuvw33uuzaal/bSMvbAx+nkTIBZss+w/D jSWRUQw1c4GN8kqi2EmYJP9qZgs5Pv/344aPeSLJgsljV6+ZvaNpfVQWJeQ/e4kaeXdUJMIM4Uo SDECNYg0yNJwcog733HEbocPF8NBzxCyLaDtjmYzWSGxWWjYBv+Dk0D6rQhPMPtDzHsuExwotBw epQj28MmifCsrAuMctI6a47o2FmCi0GVicXJfsPtx5PWj0/AwyBmZ1lePkw7GNs2LB4wklNUwB8 ZKs4NmaNXbhSv02b0GJCY9wh+RD8XQkVI4h6jfEgcl8rqfl/YAcW8cpWKmKnFV8kT4H2WarBFoY /wi6La4Yv/Hui1zESO1KBe+efXQ8WHke0BDpreurrXeU0AJH8PfaWhCBdE3IisQue54Ym3quYb8 tOFuzCve1ZmpbxqLCthWs2UdGxqJzKwTtlxoDdRmU7zfiK4Bl42AOACy7VDw879cS71owYbxDwB oxdEYx3VR2hsLaPOa5uoqsOGfFrXGoYD5CDn1ntGdMaXjE8Qtj+m24BeyNPyQgFy1j6r3wXgHG1 6lyvWN5s2JkIcKB/EiGhkzwVteRlLa6bmOFCZ2V8keia4F1P2zVFcMMCeL/ASpRWEyie8IHcrK4 rZYtsJX7OAfOnMQ== X-Developer-Key: i=bartosz.golaszewski@linaro.org; a=openpgp; fpr=169DEB6C0BC3C46013D2C79F11A72EA01471D772 From: Bartosz Golaszewski While these flags are private within drivers/gpio/, when looking at the code, it's not really clear they are GPIO-specific. Since these are GPIO descriptor flags, prepend their names with a common "GPIOD" prefix. While at it: update the flags' docs: make spelling consistent, correct outdated information, etc. Signed-off-by: Bartosz Golaszewski Reviewed-by: Linus Walleij --- drivers/gpio/gpiolib-cdev.c | 90 +++++++++++------------ drivers/gpio/gpiolib-of.c | 2 +- drivers/gpio/gpiolib-sysfs.c | 46 ++++++------ drivers/gpio/gpiolib.c | 166 +++++++++++++++++++++------------------= ---- drivers/gpio/gpiolib.h | 36 +++++----- 5 files changed, 170 insertions(+), 170 deletions(-) diff --git a/drivers/gpio/gpiolib-cdev.c b/drivers/gpio/gpiolib-cdev.c index e6a289fa0f8fd5edb3b180ef668ac8777e3dac86..175836467f216ae372a2cb6e2cd= 68c7867534938 100644 --- a/drivers/gpio/gpiolib-cdev.c +++ b/drivers/gpio/gpiolib-cdev.c @@ -144,17 +144,17 @@ static void linehandle_flags_to_desc_flags(u32 lflags= , unsigned long *flagsp) { unsigned long flags =3D READ_ONCE(*flagsp); =20 - assign_bit(FLAG_ACTIVE_LOW, &flags, + assign_bit(GPIOD_FLAG_ACTIVE_LOW, &flags, lflags & GPIOHANDLE_REQUEST_ACTIVE_LOW); - assign_bit(FLAG_OPEN_DRAIN, &flags, + assign_bit(GPIOD_FLAG_OPEN_DRAIN, &flags, lflags & GPIOHANDLE_REQUEST_OPEN_DRAIN); - assign_bit(FLAG_OPEN_SOURCE, &flags, + assign_bit(GPIOD_FLAG_OPEN_SOURCE, &flags, lflags & GPIOHANDLE_REQUEST_OPEN_SOURCE); - assign_bit(FLAG_PULL_UP, &flags, + assign_bit(GPIOD_FLAG_PULL_UP, &flags, lflags & GPIOHANDLE_REQUEST_BIAS_PULL_UP); - assign_bit(FLAG_PULL_DOWN, &flags, + assign_bit(GPIOD_FLAG_PULL_DOWN, &flags, lflags & GPIOHANDLE_REQUEST_BIAS_PULL_DOWN); - assign_bit(FLAG_BIAS_DISABLE, &flags, + assign_bit(GPIOD_FLAG_BIAS_DISABLE, &flags, lflags & GPIOHANDLE_REQUEST_BIAS_DISABLE); =20 WRITE_ONCE(*flagsp, flags); @@ -238,7 +238,7 @@ static long linehandle_ioctl(struct file *file, unsigne= d int cmd, * All line descriptors were created at once with the same * flags so just check if the first one is really output. */ - if (!test_bit(FLAG_IS_OUT, &lh->descs[0]->flags)) + if (!test_bit(GPIOD_FLAG_IS_OUT, &lh->descs[0]->flags)) return -EPERM; =20 if (copy_from_user(&ghd, ip, sizeof(ghd))) @@ -599,10 +599,10 @@ static void linereq_put_event(struct linereq *lr, =20 static u64 line_event_timestamp(struct line *line) { - if (test_bit(FLAG_EVENT_CLOCK_REALTIME, &line->desc->flags)) + if (test_bit(GPIOD_FLAG_EVENT_CLOCK_REALTIME, &line->desc->flags)) return ktime_get_real_ns(); else if (IS_ENABLED(CONFIG_HTE) && - test_bit(FLAG_EVENT_CLOCK_HTE, &line->desc->flags)) + test_bit(GPIOD_FLAG_EVENT_CLOCK_HTE, &line->desc->flags)) return line->timestamp_ns; =20 return ktime_get_ns(); @@ -725,11 +725,11 @@ static int hte_edge_setup(struct line *line, u64 efla= gs) struct hte_ts_desc *hdesc =3D &line->hdesc; =20 if (eflags & GPIO_V2_LINE_FLAG_EDGE_RISING) - flags |=3D test_bit(FLAG_ACTIVE_LOW, &line->desc->flags) ? + flags |=3D test_bit(GPIOD_FLAG_ACTIVE_LOW, &line->desc->flags) ? HTE_FALLING_EDGE_TS : HTE_RISING_EDGE_TS; if (eflags & GPIO_V2_LINE_FLAG_EDGE_FALLING) - flags |=3D test_bit(FLAG_ACTIVE_LOW, &line->desc->flags) ? + flags |=3D test_bit(GPIOD_FLAG_ACTIVE_LOW, &line->desc->flags) ? HTE_RISING_EDGE_TS : HTE_FALLING_EDGE_TS; =20 @@ -831,7 +831,7 @@ static bool debounced_value(struct line *line) */ value =3D READ_ONCE(line->level); =20 - if (test_bit(FLAG_ACTIVE_LOW, &line->desc->flags)) + if (test_bit(GPIOD_FLAG_ACTIVE_LOW, &line->desc->flags)) value =3D !value; =20 return value; @@ -939,7 +939,7 @@ static int debounce_setup(struct line *line, unsigned i= nt debounce_period_us) return level; =20 if (!(IS_ENABLED(CONFIG_HTE) && - test_bit(FLAG_EVENT_CLOCK_HTE, &line->desc->flags))) { + test_bit(GPIOD_FLAG_EVENT_CLOCK_HTE, &line->desc->flags))) { irq =3D gpiod_to_irq(line->desc); if (irq < 0) return -ENXIO; @@ -1061,10 +1061,10 @@ static int edge_detector_setup(struct line *line, return -ENXIO; =20 if (eflags & GPIO_V2_LINE_FLAG_EDGE_RISING) - irqflags |=3D test_bit(FLAG_ACTIVE_LOW, &line->desc->flags) ? + irqflags |=3D test_bit(GPIOD_FLAG_ACTIVE_LOW, &line->desc->flags) ? IRQF_TRIGGER_FALLING : IRQF_TRIGGER_RISING; if (eflags & GPIO_V2_LINE_FLAG_EDGE_FALLING) - irqflags |=3D test_bit(FLAG_ACTIVE_LOW, &line->desc->flags) ? + irqflags |=3D test_bit(GPIOD_FLAG_ACTIVE_LOW, &line->desc->flags) ? IRQF_TRIGGER_RISING : IRQF_TRIGGER_FALLING; irqflags |=3D IRQF_ONESHOT; =20 @@ -1237,34 +1237,34 @@ static void gpio_v2_line_config_flags_to_desc_flags= (u64 lflags, { unsigned long flags =3D READ_ONCE(*flagsp); =20 - assign_bit(FLAG_ACTIVE_LOW, &flags, + assign_bit(GPIOD_FLAG_ACTIVE_LOW, &flags, lflags & GPIO_V2_LINE_FLAG_ACTIVE_LOW); =20 if (lflags & GPIO_V2_LINE_FLAG_OUTPUT) - set_bit(FLAG_IS_OUT, &flags); + set_bit(GPIOD_FLAG_IS_OUT, &flags); else if (lflags & GPIO_V2_LINE_FLAG_INPUT) - clear_bit(FLAG_IS_OUT, &flags); + clear_bit(GPIOD_FLAG_IS_OUT, &flags); =20 - assign_bit(FLAG_EDGE_RISING, &flags, + assign_bit(GPIOD_FLAG_EDGE_RISING, &flags, lflags & GPIO_V2_LINE_FLAG_EDGE_RISING); - assign_bit(FLAG_EDGE_FALLING, &flags, + assign_bit(GPIOD_FLAG_EDGE_FALLING, &flags, lflags & GPIO_V2_LINE_FLAG_EDGE_FALLING); =20 - assign_bit(FLAG_OPEN_DRAIN, &flags, + assign_bit(GPIOD_FLAG_OPEN_DRAIN, &flags, lflags & GPIO_V2_LINE_FLAG_OPEN_DRAIN); - assign_bit(FLAG_OPEN_SOURCE, &flags, + assign_bit(GPIOD_FLAG_OPEN_SOURCE, &flags, lflags & GPIO_V2_LINE_FLAG_OPEN_SOURCE); =20 - assign_bit(FLAG_PULL_UP, &flags, + assign_bit(GPIOD_FLAG_PULL_UP, &flags, lflags & GPIO_V2_LINE_FLAG_BIAS_PULL_UP); - assign_bit(FLAG_PULL_DOWN, &flags, + assign_bit(GPIOD_FLAG_PULL_DOWN, &flags, lflags & GPIO_V2_LINE_FLAG_BIAS_PULL_DOWN); - assign_bit(FLAG_BIAS_DISABLE, &flags, + assign_bit(GPIOD_FLAG_BIAS_DISABLE, &flags, lflags & GPIO_V2_LINE_FLAG_BIAS_DISABLED); =20 - assign_bit(FLAG_EVENT_CLOCK_REALTIME, &flags, + assign_bit(GPIOD_FLAG_EVENT_CLOCK_REALTIME, &flags, lflags & GPIO_V2_LINE_FLAG_EVENT_CLOCK_REALTIME); - assign_bit(FLAG_EVENT_CLOCK_HTE, &flags, + assign_bit(GPIOD_FLAG_EVENT_CLOCK_HTE, &flags, lflags & GPIO_V2_LINE_FLAG_EVENT_CLOCK_HTE); =20 WRITE_ONCE(*flagsp, flags); @@ -2115,10 +2115,10 @@ static int lineevent_create(struct gpio_device *gde= v, void __user *ip) } =20 if (eflags & GPIOEVENT_REQUEST_RISING_EDGE) - irqflags |=3D test_bit(FLAG_ACTIVE_LOW, &desc->flags) ? + irqflags |=3D test_bit(GPIOD_FLAG_ACTIVE_LOW, &desc->flags) ? IRQF_TRIGGER_FALLING : IRQF_TRIGGER_RISING; if (eflags & GPIOEVENT_REQUEST_FALLING_EDGE) - irqflags |=3D test_bit(FLAG_ACTIVE_LOW, &desc->flags) ? + irqflags |=3D test_bit(GPIOD_FLAG_ACTIVE_LOW, &desc->flags) ? IRQF_TRIGGER_RISING : IRQF_TRIGGER_FALLING; irqflags |=3D IRQF_ONESHOT; =20 @@ -2253,7 +2253,7 @@ static void gpio_desc_to_lineinfo(struct gpio_desc *d= esc, =20 scoped_guard(srcu, &desc->gdev->desc_srcu) { label =3D gpiod_get_label(desc); - if (label && test_bit(FLAG_REQUESTED, &dflags)) + if (label && test_bit(GPIOD_FLAG_REQUESTED, &dflags)) strscpy(info->consumer, label, sizeof(info->consumer)); } @@ -2270,10 +2270,10 @@ static void gpio_desc_to_lineinfo(struct gpio_desc = *desc, * The definitive test that a line is available to userspace is to * request it. */ - if (test_bit(FLAG_REQUESTED, &dflags) || - test_bit(FLAG_IS_HOGGED, &dflags) || - test_bit(FLAG_EXPORT, &dflags) || - test_bit(FLAG_SYSFS, &dflags) || + if (test_bit(GPIOD_FLAG_REQUESTED, &dflags) || + test_bit(GPIOD_FLAG_IS_HOGGED, &dflags) || + test_bit(GPIOD_FLAG_EXPORT, &dflags) || + test_bit(GPIOD_FLAG_SYSFS, &dflags) || !gpiochip_line_is_valid(guard.gc, info->offset)) { info->flags |=3D GPIO_V2_LINE_FLAG_USED; } else if (!atomic) { @@ -2281,34 +2281,34 @@ static void gpio_desc_to_lineinfo(struct gpio_desc = *desc, info->flags |=3D GPIO_V2_LINE_FLAG_USED; } =20 - if (test_bit(FLAG_IS_OUT, &dflags)) + if (test_bit(GPIOD_FLAG_IS_OUT, &dflags)) info->flags |=3D GPIO_V2_LINE_FLAG_OUTPUT; else info->flags |=3D GPIO_V2_LINE_FLAG_INPUT; =20 - if (test_bit(FLAG_ACTIVE_LOW, &dflags)) + if (test_bit(GPIOD_FLAG_ACTIVE_LOW, &dflags)) info->flags |=3D GPIO_V2_LINE_FLAG_ACTIVE_LOW; =20 - if (test_bit(FLAG_OPEN_DRAIN, &dflags)) + if (test_bit(GPIOD_FLAG_OPEN_DRAIN, &dflags)) info->flags |=3D GPIO_V2_LINE_FLAG_OPEN_DRAIN; - if (test_bit(FLAG_OPEN_SOURCE, &dflags)) + if (test_bit(GPIOD_FLAG_OPEN_SOURCE, &dflags)) info->flags |=3D GPIO_V2_LINE_FLAG_OPEN_SOURCE; =20 - if (test_bit(FLAG_BIAS_DISABLE, &dflags)) + if (test_bit(GPIOD_FLAG_BIAS_DISABLE, &dflags)) info->flags |=3D GPIO_V2_LINE_FLAG_BIAS_DISABLED; - if (test_bit(FLAG_PULL_DOWN, &dflags)) + if (test_bit(GPIOD_FLAG_PULL_DOWN, &dflags)) info->flags |=3D GPIO_V2_LINE_FLAG_BIAS_PULL_DOWN; - if (test_bit(FLAG_PULL_UP, &dflags)) + if (test_bit(GPIOD_FLAG_PULL_UP, &dflags)) info->flags |=3D GPIO_V2_LINE_FLAG_BIAS_PULL_UP; =20 - if (test_bit(FLAG_EDGE_RISING, &dflags)) + if (test_bit(GPIOD_FLAG_EDGE_RISING, &dflags)) info->flags |=3D GPIO_V2_LINE_FLAG_EDGE_RISING; - if (test_bit(FLAG_EDGE_FALLING, &dflags)) + if (test_bit(GPIOD_FLAG_EDGE_FALLING, &dflags)) info->flags |=3D GPIO_V2_LINE_FLAG_EDGE_FALLING; =20 - if (test_bit(FLAG_EVENT_CLOCK_REALTIME, &dflags)) + if (test_bit(GPIOD_FLAG_EVENT_CLOCK_REALTIME, &dflags)) info->flags |=3D GPIO_V2_LINE_FLAG_EVENT_CLOCK_REALTIME; - else if (test_bit(FLAG_EVENT_CLOCK_HTE, &dflags)) + else if (test_bit(GPIOD_FLAG_EVENT_CLOCK_HTE, &dflags)) info->flags |=3D GPIO_V2_LINE_FLAG_EVENT_CLOCK_HTE; =20 debounce_period_us =3D READ_ONCE(desc->debounce_period_us); diff --git a/drivers/gpio/gpiolib-of.c b/drivers/gpio/gpiolib-of.c index 37ab78243faba2feefb36b7edc53598021543295..fad4edf9cc5c0c0469795b20695= 65e73e0d9c9ef 100644 --- a/drivers/gpio/gpiolib-of.c +++ b/drivers/gpio/gpiolib-of.c @@ -878,7 +878,7 @@ static void of_gpiochip_remove_hog(struct gpio_chip *ch= ip, { struct gpio_desc *desc; =20 - for_each_gpio_desc_with_flag(chip, desc, FLAG_IS_HOGGED) + for_each_gpio_desc_with_flag(chip, desc, GPIOD_FLAG_IS_HOGGED) if (READ_ONCE(desc->hog) =3D=3D hog) gpiochip_free_own_desc(desc); } diff --git a/drivers/gpio/gpiolib-sysfs.c b/drivers/gpio/gpiolib-sysfs.c index b64106f1cb7b90ac2c3595c5d1101cba93fa0e6a..9a849245b35880b66afeb042a8b= b25520279e9a7 100644 --- a/drivers/gpio/gpiolib-sysfs.c +++ b/drivers/gpio/gpiolib-sysfs.c @@ -131,7 +131,7 @@ static ssize_t direction_show(struct device *dev, =20 scoped_guard(mutex, &data->mutex) { gpiod_get_direction(desc); - value =3D !!test_bit(FLAG_IS_OUT, &desc->flags); + value =3D !!test_bit(GPIOD_FLAG_IS_OUT, &desc->flags); } =20 return sysfs_emit(buf, "%s\n", value ? "out" : "in"); @@ -226,14 +226,14 @@ static int gpio_sysfs_request_irq(struct gpiod_data *= data, unsigned char flags) =20 irq_flags =3D IRQF_SHARED; if (flags & GPIO_IRQF_TRIGGER_FALLING) { - irq_flags |=3D test_bit(FLAG_ACTIVE_LOW, &desc->flags) ? + irq_flags |=3D test_bit(GPIOD_FLAG_ACTIVE_LOW, &desc->flags) ? IRQF_TRIGGER_RISING : IRQF_TRIGGER_FALLING; - set_bit(FLAG_EDGE_FALLING, &desc->flags); + set_bit(GPIOD_FLAG_EDGE_FALLING, &desc->flags); } if (flags & GPIO_IRQF_TRIGGER_RISING) { - irq_flags |=3D test_bit(FLAG_ACTIVE_LOW, &desc->flags) ? + irq_flags |=3D test_bit(GPIOD_FLAG_ACTIVE_LOW, &desc->flags) ? IRQF_TRIGGER_FALLING : IRQF_TRIGGER_RISING; - set_bit(FLAG_EDGE_RISING, &desc->flags); + set_bit(GPIOD_FLAG_EDGE_RISING, &desc->flags); } =20 /* @@ -260,8 +260,8 @@ static int gpio_sysfs_request_irq(struct gpiod_data *da= ta, unsigned char flags) err_unlock: gpiochip_unlock_as_irq(guard.gc, gpio_chip_hwgpio(desc)); err_clr_bits: - clear_bit(FLAG_EDGE_RISING, &desc->flags); - clear_bit(FLAG_EDGE_FALLING, &desc->flags); + clear_bit(GPIOD_FLAG_EDGE_RISING, &desc->flags); + clear_bit(GPIOD_FLAG_EDGE_FALLING, &desc->flags); =20 return ret; } @@ -281,8 +281,8 @@ static void gpio_sysfs_free_irq(struct gpiod_data *data) data->irq_flags =3D 0; free_irq(data->irq, data); gpiochip_unlock_as_irq(guard.gc, gpio_chip_hwgpio(desc)); - clear_bit(FLAG_EDGE_RISING, &desc->flags); - clear_bit(FLAG_EDGE_FALLING, &desc->flags); + clear_bit(GPIOD_FLAG_EDGE_RISING, &desc->flags); + clear_bit(GPIOD_FLAG_EDGE_FALLING, &desc->flags); } =20 static const char *const trigger_names[] =3D { @@ -347,10 +347,10 @@ static int gpio_sysfs_set_active_low(struct gpiod_dat= a *data, int value) struct gpio_desc *desc =3D data->desc; int status =3D 0; =20 - if (!!test_bit(FLAG_ACTIVE_LOW, &desc->flags) =3D=3D !!value) + if (!!test_bit(GPIOD_FLAG_ACTIVE_LOW, &desc->flags) =3D=3D !!value) return 0; =20 - assign_bit(FLAG_ACTIVE_LOW, &desc->flags, value); + assign_bit(GPIOD_FLAG_ACTIVE_LOW, &desc->flags, value); =20 /* reconfigure poll(2) support if enabled on one edge only */ if (flags =3D=3D GPIO_IRQF_TRIGGER_FALLING || @@ -373,7 +373,7 @@ static ssize_t active_low_show(struct device *dev, int value; =20 scoped_guard(mutex, &data->mutex) - value =3D !!test_bit(FLAG_ACTIVE_LOW, &desc->flags); + value =3D !!test_bit(GPIOD_FLAG_ACTIVE_LOW, &desc->flags); =20 return sysfs_emit(buf, "%d\n", value); } @@ -418,7 +418,7 @@ static umode_t gpio_is_visible(struct kobject *kobj, st= ruct attribute *attr, mode =3D 0; =20 if (!data->direction_can_change && - test_bit(FLAG_IS_OUT, &data->desc->flags)) + test_bit(GPIOD_FLAG_IS_OUT, &data->desc->flags)) mode =3D 0; #endif /* CONFIG_GPIO_SYSFS_LEGACY */ } @@ -486,7 +486,7 @@ static int export_gpio_desc(struct gpio_desc *desc) } =20 /* - * No extra locking here; FLAG_SYSFS just signifies that the + * No extra locking here; GPIOD_FLAG_SYSFS just signifies that the * request and export were done by on behalf of userspace, so * they may be undone on its behalf too. */ @@ -505,7 +505,7 @@ static int export_gpio_desc(struct gpio_desc *desc) if (ret < 0) { gpiod_free(desc); } else { - set_bit(FLAG_SYSFS, &desc->flags); + set_bit(GPIOD_FLAG_SYSFS, &desc->flags); gpiod_line_state_notify(desc, GPIO_V2_LINE_CHANGED_REQUESTED); } =20 @@ -515,11 +515,11 @@ static int export_gpio_desc(struct gpio_desc *desc) static int unexport_gpio_desc(struct gpio_desc *desc) { /* - * No extra locking here; FLAG_SYSFS just signifies that the + * No extra locking here; GPIOD_FLAG_SYSFS just signifies that the * request and export were done by on behalf of userspace, so * they may be undone on its behalf too. */ - if (!test_and_clear_bit(FLAG_SYSFS, &desc->flags)) + if (!test_and_clear_bit(GPIOD_FLAG_SYSFS, &desc->flags)) return -EINVAL; =20 gpiod_unexport(desc); @@ -748,14 +748,14 @@ int gpiod_export(struct gpio_desc *desc, bool directi= on_may_change) if (!guard.gc) return -ENODEV; =20 - if (test_and_set_bit(FLAG_EXPORT, &desc->flags)) + if (test_and_set_bit(GPIOD_FLAG_EXPORT, &desc->flags)) return -EPERM; =20 gdev =3D desc->gdev; =20 guard(mutex)(&sysfs_lock); =20 - if (!test_bit(FLAG_REQUESTED, &desc->flags)) { + if (!test_bit(GPIOD_FLAG_REQUESTED, &desc->flags)) { gpiod_dbg(desc, "%s: unavailable (not requested)\n", __func__); status =3D -EPERM; goto err_clear_bit; @@ -866,7 +866,7 @@ int gpiod_export(struct gpio_desc *desc, bool direction= _may_change) #endif /* CONFIG_GPIO_SYSFS_LEGACY */ kfree(desc_data); err_clear_bit: - clear_bit(FLAG_EXPORT, &desc->flags); + clear_bit(GPIOD_FLAG_EXPORT, &desc->flags); gpiod_dbg(desc, "%s: status %d\n", __func__, status); return status; } @@ -937,7 +937,7 @@ void gpiod_unexport(struct gpio_desc *desc) } =20 scoped_guard(mutex, &sysfs_lock) { - if (!test_bit(FLAG_EXPORT, &desc->flags)) + if (!test_bit(GPIOD_FLAG_EXPORT, &desc->flags)) return; =20 gdev =3D gpiod_to_gpio_device(desc); @@ -956,7 +956,7 @@ void gpiod_unexport(struct gpio_desc *desc) return; =20 list_del(&desc_data->list); - clear_bit(FLAG_EXPORT, &desc->flags); + clear_bit(GPIOD_FLAG_EXPORT, &desc->flags); #if IS_ENABLED(CONFIG_GPIO_SYSFS_LEGACY) sysfs_put(desc_data->value_kn); device_unregister(desc_data->dev); @@ -1073,7 +1073,7 @@ void gpiochip_sysfs_unregister(struct gpio_device *gd= ev) return; =20 /* unregister gpiod class devices owned by sysfs */ - for_each_gpio_desc_with_flag(chip, desc, FLAG_SYSFS) { + for_each_gpio_desc_with_flag(chip, desc, GPIOD_FLAG_SYSFS) { gpiod_unexport(desc); gpiod_free(desc); } diff --git a/drivers/gpio/gpiolib.c b/drivers/gpio/gpiolib.c index 98d2fa602490566b0c78ba0171297ed2ec11e393..01bdf8fad7cff6c507e79b8880e= 9335d7ee53173 100644 --- a/drivers/gpio/gpiolib.c +++ b/drivers/gpio/gpiolib.c @@ -127,10 +127,10 @@ const char *gpiod_get_label(struct gpio_desc *desc) label =3D srcu_dereference_check(desc->label, &desc->gdev->desc_srcu, srcu_read_lock_held(&desc->gdev->desc_srcu)); =20 - if (test_bit(FLAG_USED_AS_IRQ, &flags)) + if (test_bit(GPIOD_FLAG_USED_AS_IRQ, &flags)) return label ? label->str : "interrupt"; =20 - if (!test_bit(FLAG_REQUESTED, &flags)) + if (!test_bit(GPIOD_FLAG_REQUESTED, &flags)) return NULL; =20 return label ? label->str : NULL; @@ -450,8 +450,8 @@ int gpiod_get_direction(struct gpio_desc *desc) * Open drain emulation using input mode may incorrectly report * input here, fix that up. */ - if (test_bit(FLAG_OPEN_DRAIN, &flags) && - test_bit(FLAG_IS_OUT, &flags)) + if (test_bit(GPIOD_FLAG_OPEN_DRAIN, &flags) && + test_bit(GPIOD_FLAG_IS_OUT, &flags)) return 0; =20 if (!guard.gc->get_direction) @@ -468,7 +468,7 @@ int gpiod_get_direction(struct gpio_desc *desc) if (ret > 0) ret =3D 1; =20 - assign_bit(FLAG_IS_OUT, &flags, !ret); + assign_bit(GPIOD_FLAG_IS_OUT, &flags, !ret); WRITE_ONCE(desc->flags, flags); =20 return ret; @@ -846,7 +846,7 @@ static void gpiochip_free_remaining_irqs(struct gpio_ch= ip *gc) { struct gpio_desc *desc; =20 - for_each_gpio_desc_with_flag(gc, desc, FLAG_USED_AS_IRQ) + for_each_gpio_desc_with_flag(gc, desc, GPIOD_FLAG_USED_AS_IRQ) gpiod_free_irqs(desc); } =20 @@ -1169,10 +1169,10 @@ int gpiochip_add_data_with_key(struct gpio_chip *gc= , void *data, * lock here. */ if (gc->get_direction && gpiochip_line_is_valid(gc, desc_index)) - assign_bit(FLAG_IS_OUT, &desc->flags, + assign_bit(GPIOD_FLAG_IS_OUT, &desc->flags, !gc->get_direction(gc, desc_index)); else - assign_bit(FLAG_IS_OUT, + assign_bit(GPIOD_FLAG_IS_OUT, &desc->flags, !gc->direction_input); } =20 @@ -2449,7 +2449,7 @@ static int gpiod_request_commit(struct gpio_desc *des= c, const char *label) if (!guard.gc) return -ENODEV; =20 - if (test_and_set_bit(FLAG_REQUESTED, &desc->flags)) + if (test_and_set_bit(GPIOD_FLAG_REQUESTED, &desc->flags)) return -EBUSY; =20 offset =3D gpio_chip_hwgpio(desc); @@ -2478,7 +2478,7 @@ static int gpiod_request_commit(struct gpio_desc *des= c, const char *label) return 0; =20 out_clear_bit: - clear_bit(FLAG_REQUESTED, &desc->flags); + clear_bit(GPIOD_FLAG_REQUESTED, &desc->flags); return ret; } =20 @@ -2512,20 +2512,20 @@ static void gpiod_free_commit(struct gpio_desc *des= c) =20 flags =3D READ_ONCE(desc->flags); =20 - if (guard.gc && test_bit(FLAG_REQUESTED, &flags)) { + if (guard.gc && test_bit(GPIOD_FLAG_REQUESTED, &flags)) { if (guard.gc->free) guard.gc->free(guard.gc, gpio_chip_hwgpio(desc)); =20 - clear_bit(FLAG_ACTIVE_LOW, &flags); - clear_bit(FLAG_REQUESTED, &flags); - clear_bit(FLAG_OPEN_DRAIN, &flags); - clear_bit(FLAG_OPEN_SOURCE, &flags); - clear_bit(FLAG_PULL_UP, &flags); - clear_bit(FLAG_PULL_DOWN, &flags); - clear_bit(FLAG_BIAS_DISABLE, &flags); - clear_bit(FLAG_EDGE_RISING, &flags); - clear_bit(FLAG_EDGE_FALLING, &flags); - clear_bit(FLAG_IS_HOGGED, &flags); + clear_bit(GPIOD_FLAG_ACTIVE_LOW, &flags); + clear_bit(GPIOD_FLAG_REQUESTED, &flags); + clear_bit(GPIOD_FLAG_OPEN_DRAIN, &flags); + clear_bit(GPIOD_FLAG_OPEN_SOURCE, &flags); + clear_bit(GPIOD_FLAG_PULL_UP, &flags); + clear_bit(GPIOD_FLAG_PULL_DOWN, &flags); + clear_bit(GPIOD_FLAG_BIAS_DISABLE, &flags); + clear_bit(GPIOD_FLAG_EDGE_RISING, &flags); + clear_bit(GPIOD_FLAG_EDGE_FALLING, &flags); + clear_bit(GPIOD_FLAG_IS_HOGGED, &flags); #ifdef CONFIG_OF_DYNAMIC WRITE_ONCE(desc->hog, NULL); #endif @@ -2568,7 +2568,7 @@ char *gpiochip_dup_line_label(struct gpio_chip *gc, u= nsigned int offset) if (IS_ERR(desc)) return NULL; =20 - if (!test_bit(FLAG_REQUESTED, &desc->flags)) + if (!test_bit(GPIOD_FLAG_REQUESTED, &desc->flags)) return NULL; =20 guard(srcu)(&desc->gdev->desc_srcu); @@ -2736,11 +2736,11 @@ static int gpio_set_bias(struct gpio_desc *desc) =20 flags =3D READ_ONCE(desc->flags); =20 - if (test_bit(FLAG_BIAS_DISABLE, &flags)) + if (test_bit(GPIOD_FLAG_BIAS_DISABLE, &flags)) bias =3D PIN_CONFIG_BIAS_DISABLE; - else if (test_bit(FLAG_PULL_UP, &flags)) + else if (test_bit(GPIOD_FLAG_PULL_UP, &flags)) bias =3D PIN_CONFIG_BIAS_PULL_UP; - else if (test_bit(FLAG_PULL_DOWN, &flags)) + else if (test_bit(GPIOD_FLAG_PULL_DOWN, &flags)) bias =3D PIN_CONFIG_BIAS_PULL_DOWN; else return 0; @@ -2882,7 +2882,7 @@ int gpiod_direction_input_nonotify(struct gpio_desc *= desc) } } if (ret =3D=3D 0) { - clear_bit(FLAG_IS_OUT, &desc->flags); + clear_bit(GPIOD_FLAG_IS_OUT, &desc->flags); ret =3D gpio_set_bias(desc); } =20 @@ -2955,7 +2955,7 @@ static int gpiod_direction_output_raw_commit(struct g= pio_desc *desc, int value) } =20 if (!ret) - set_bit(FLAG_IS_OUT, &desc->flags); + set_bit(GPIOD_FLAG_IS_OUT, &desc->flags); trace_gpio_value(desc_to_gpio(desc), 0, val); trace_gpio_direction(desc_to_gpio(desc), 0, ret); return ret; @@ -3021,21 +3021,21 @@ int gpiod_direction_output_nonotify(struct gpio_des= c *desc, int value) =20 flags =3D READ_ONCE(desc->flags); =20 - if (test_bit(FLAG_ACTIVE_LOW, &flags)) + if (test_bit(GPIOD_FLAG_ACTIVE_LOW, &flags)) value =3D !value; else value =3D !!value; =20 /* GPIOs used for enabled IRQs shall not be set as output */ - if (test_bit(FLAG_USED_AS_IRQ, &flags) && - test_bit(FLAG_IRQ_IS_ENABLED, &flags)) { + if (test_bit(GPIOD_FLAG_USED_AS_IRQ, &flags) && + test_bit(GPIOD_FLAG_IRQ_IS_ENABLED, &flags)) { gpiod_err(desc, "%s: tried to set a GPIO tied to an IRQ as output\n", __func__); return -EIO; } =20 - if (test_bit(FLAG_OPEN_DRAIN, &flags)) { + if (test_bit(GPIOD_FLAG_OPEN_DRAIN, &flags)) { /* First see if we can enable open drain in hardware */ ret =3D gpio_set_config(desc, PIN_CONFIG_DRIVE_OPEN_DRAIN); if (!ret) @@ -3043,7 +3043,7 @@ int gpiod_direction_output_nonotify(struct gpio_desc = *desc, int value) /* Emulate open drain by not actively driving the line high */ if (value) goto set_output_flag; - } else if (test_bit(FLAG_OPEN_SOURCE, &flags)) { + } else if (test_bit(GPIOD_FLAG_OPEN_SOURCE, &flags)) { ret =3D gpio_set_config(desc, PIN_CONFIG_DRIVE_OPEN_SOURCE); if (!ret) goto set_output_value; @@ -3070,7 +3070,7 @@ int gpiod_direction_output_nonotify(struct gpio_desc = *desc, int value) * set the IS_OUT flag or otherwise we won't be able to set the line * value anymore. */ - set_bit(FLAG_IS_OUT, &desc->flags); + set_bit(GPIOD_FLAG_IS_OUT, &desc->flags); return 0; } =20 @@ -3210,10 +3210,10 @@ int gpiod_set_transitory(struct gpio_desc *desc, bo= ol transitory) { VALIDATE_DESC(desc); /* - * Handle FLAG_TRANSITORY first, enabling queries to gpiolib for + * Handle GPIOD_FLAG_TRANSITORY first, enabling queries to gpiolib for * persistence state. */ - assign_bit(FLAG_TRANSITORY, &desc->flags, transitory); + assign_bit(GPIOD_FLAG_TRANSITORY, &desc->flags, transitory); =20 /* If the driver supports it, set the persistence state now */ return gpio_set_config_with_argument_optional(desc, @@ -3231,7 +3231,7 @@ int gpiod_set_transitory(struct gpio_desc *desc, bool= transitory) int gpiod_is_active_low(const struct gpio_desc *desc) { VALIDATE_DESC(desc); - return test_bit(FLAG_ACTIVE_LOW, &desc->flags); + return test_bit(GPIOD_FLAG_ACTIVE_LOW, &desc->flags); } EXPORT_SYMBOL_GPL(gpiod_is_active_low); =20 @@ -3242,7 +3242,7 @@ EXPORT_SYMBOL_GPL(gpiod_is_active_low); void gpiod_toggle_active_low(struct gpio_desc *desc) { VALIDATE_DESC_VOID(desc); - change_bit(FLAG_ACTIVE_LOW, &desc->flags); + change_bit(GPIOD_FLAG_ACTIVE_LOW, &desc->flags); gpiod_line_state_notify(desc, GPIO_V2_LINE_CHANGED_CONFIG); } EXPORT_SYMBOL_GPL(gpiod_toggle_active_low); @@ -3448,7 +3448,7 @@ int gpiod_get_array_value_complex(bool raw, bool can_= sleep, int hwgpio =3D gpio_chip_hwgpio(desc); int value =3D test_bit(hwgpio, bits); =20 - if (!raw && test_bit(FLAG_ACTIVE_LOW, &desc->flags)) + if (!raw && test_bit(GPIOD_FLAG_ACTIVE_LOW, &desc->flags)) value =3D !value; __assign_bit(j, value_bitmap, value); trace_gpio_value(desc_to_gpio(desc), 1, value); @@ -3510,7 +3510,7 @@ int gpiod_get_value(const struct gpio_desc *desc) if (value < 0) return value; =20 - if (test_bit(FLAG_ACTIVE_LOW, &desc->flags)) + if (test_bit(GPIOD_FLAG_ACTIVE_LOW, &desc->flags)) value =3D !value; =20 return value; @@ -3593,7 +3593,7 @@ static int gpio_set_open_drain_value_commit(struct gp= io_desc *desc, bool value) } else { ret =3D gpiochip_direction_output(guard.gc, offset, 0); if (!ret) - set_bit(FLAG_IS_OUT, &desc->flags); + set_bit(GPIOD_FLAG_IS_OUT, &desc->flags); } trace_gpio_direction(desc_to_gpio(desc), value, ret); if (ret < 0) @@ -3620,7 +3620,7 @@ static int gpio_set_open_source_value_commit(struct g= pio_desc *desc, bool value) if (value) { ret =3D gpiochip_direction_output(guard.gc, offset, 1); if (!ret) - set_bit(FLAG_IS_OUT, &desc->flags); + set_bit(GPIOD_FLAG_IS_OUT, &desc->flags); } else { ret =3D gpiochip_direction_input(guard.gc, offset); } @@ -3635,7 +3635,7 @@ static int gpio_set_open_source_value_commit(struct g= pio_desc *desc, bool value) =20 static int gpiod_set_raw_value_commit(struct gpio_desc *desc, bool value) { - if (unlikely(!test_bit(FLAG_IS_OUT, &desc->flags))) + if (unlikely(!test_bit(GPIOD_FLAG_IS_OUT, &desc->flags))) return -EPERM; =20 CLASS(gpio_chip_guard, guard)(desc); @@ -3705,7 +3705,7 @@ int gpiod_set_array_value_complex(bool raw, bool can_= sleep, WARN_ON(array_info->gdev->can_sleep); =20 for (i =3D 0; i < array_size; i++) { - if (unlikely(!test_bit(FLAG_IS_OUT, + if (unlikely(!test_bit(GPIOD_FLAG_IS_OUT, &desc_array[i]->flags))) return -EPERM; } @@ -3769,7 +3769,7 @@ int gpiod_set_array_value_complex(bool raw, bool can_= sleep, int hwgpio =3D gpio_chip_hwgpio(desc); int value =3D test_bit(i, value_bitmap); =20 - if (unlikely(!test_bit(FLAG_IS_OUT, &desc->flags))) + if (unlikely(!test_bit(GPIOD_FLAG_IS_OUT, &desc->flags))) return -EPERM; =20 /* @@ -3779,16 +3779,16 @@ int gpiod_set_array_value_complex(bool raw, bool ca= n_sleep, */ if (!raw && !(array_info && test_bit(i, array_info->invert_mask)) && - test_bit(FLAG_ACTIVE_LOW, &desc->flags)) + test_bit(GPIOD_FLAG_ACTIVE_LOW, &desc->flags)) value =3D !value; trace_gpio_value(desc_to_gpio(desc), 0, value); /* * collect all normal outputs belonging to the same chip * open drain and open source outputs are set individually */ - if (test_bit(FLAG_OPEN_DRAIN, &desc->flags) && !raw) { + if (test_bit(GPIOD_FLAG_OPEN_DRAIN, &desc->flags) && !raw) { gpio_set_open_drain_value_commit(desc, value); - } else if (test_bit(FLAG_OPEN_SOURCE, &desc->flags) && !raw) { + } else if (test_bit(GPIOD_FLAG_OPEN_SOURCE, &desc->flags) && !raw) { gpio_set_open_source_value_commit(desc, value); } else { __set_bit(hwgpio, mask); @@ -3854,12 +3854,12 @@ EXPORT_SYMBOL_GPL(gpiod_set_raw_value); */ static int gpiod_set_value_nocheck(struct gpio_desc *desc, int value) { - if (test_bit(FLAG_ACTIVE_LOW, &desc->flags)) + if (test_bit(GPIOD_FLAG_ACTIVE_LOW, &desc->flags)) value =3D !value; =20 - if (test_bit(FLAG_OPEN_DRAIN, &desc->flags)) + if (test_bit(GPIOD_FLAG_OPEN_DRAIN, &desc->flags)) return gpio_set_open_drain_value_commit(desc, value); - else if (test_bit(FLAG_OPEN_SOURCE, &desc->flags)) + else if (test_bit(GPIOD_FLAG_OPEN_SOURCE, &desc->flags)) return gpio_set_open_source_value_commit(desc, value); =20 return gpiod_set_raw_value_commit(desc, value); @@ -4063,16 +4063,16 @@ int gpiochip_lock_as_irq(struct gpio_chip *gc, unsi= gned int offset) } =20 /* To be valid for IRQ the line needs to be input or open drain */ - if (test_bit(FLAG_IS_OUT, &desc->flags) && - !test_bit(FLAG_OPEN_DRAIN, &desc->flags)) { + if (test_bit(GPIOD_FLAG_IS_OUT, &desc->flags) && + !test_bit(GPIOD_FLAG_OPEN_DRAIN, &desc->flags)) { chip_err(gc, "%s: tried to flag a GPIO set as output for IRQ\n", __func__); return -EIO; } =20 - set_bit(FLAG_USED_AS_IRQ, &desc->flags); - set_bit(FLAG_IRQ_IS_ENABLED, &desc->flags); + set_bit(GPIOD_FLAG_USED_AS_IRQ, &desc->flags); + set_bit(GPIOD_FLAG_IRQ_IS_ENABLED, &desc->flags); =20 return 0; } @@ -4094,8 +4094,8 @@ void gpiochip_unlock_as_irq(struct gpio_chip *gc, uns= igned int offset) if (IS_ERR(desc)) return; =20 - clear_bit(FLAG_USED_AS_IRQ, &desc->flags); - clear_bit(FLAG_IRQ_IS_ENABLED, &desc->flags); + clear_bit(GPIOD_FLAG_USED_AS_IRQ, &desc->flags); + clear_bit(GPIOD_FLAG_IRQ_IS_ENABLED, &desc->flags); } EXPORT_SYMBOL_GPL(gpiochip_unlock_as_irq); =20 @@ -4104,8 +4104,8 @@ void gpiochip_disable_irq(struct gpio_chip *gc, unsig= ned int offset) struct gpio_desc *desc =3D gpiochip_get_desc(gc, offset); =20 if (!IS_ERR(desc) && - !WARN_ON(!test_bit(FLAG_USED_AS_IRQ, &desc->flags))) - clear_bit(FLAG_IRQ_IS_ENABLED, &desc->flags); + !WARN_ON(!test_bit(GPIOD_FLAG_USED_AS_IRQ, &desc->flags))) + clear_bit(GPIOD_FLAG_IRQ_IS_ENABLED, &desc->flags); } EXPORT_SYMBOL_GPL(gpiochip_disable_irq); =20 @@ -4114,14 +4114,14 @@ void gpiochip_enable_irq(struct gpio_chip *gc, unsi= gned int offset) struct gpio_desc *desc =3D gpiochip_get_desc(gc, offset); =20 if (!IS_ERR(desc) && - !WARN_ON(!test_bit(FLAG_USED_AS_IRQ, &desc->flags))) { + !WARN_ON(!test_bit(GPIOD_FLAG_USED_AS_IRQ, &desc->flags))) { /* * We must not be output when using IRQ UNLESS we are * open drain. */ - WARN_ON(test_bit(FLAG_IS_OUT, &desc->flags) && - !test_bit(FLAG_OPEN_DRAIN, &desc->flags)); - set_bit(FLAG_IRQ_IS_ENABLED, &desc->flags); + WARN_ON(test_bit(GPIOD_FLAG_IS_OUT, &desc->flags) && + !test_bit(GPIOD_FLAG_OPEN_DRAIN, &desc->flags)); + set_bit(GPIOD_FLAG_IRQ_IS_ENABLED, &desc->flags); } } EXPORT_SYMBOL_GPL(gpiochip_enable_irq); @@ -4131,7 +4131,7 @@ bool gpiochip_line_is_irq(struct gpio_chip *gc, unsig= ned int offset) if (offset >=3D gc->ngpio) return false; =20 - return test_bit(FLAG_USED_AS_IRQ, &gc->gpiodev->descs[offset].flags); + return test_bit(GPIOD_FLAG_USED_AS_IRQ, &gc->gpiodev->descs[offset].flags= ); } EXPORT_SYMBOL_GPL(gpiochip_line_is_irq); =20 @@ -4164,7 +4164,7 @@ bool gpiochip_line_is_open_drain(struct gpio_chip *gc= , unsigned int offset) if (offset >=3D gc->ngpio) return false; =20 - return test_bit(FLAG_OPEN_DRAIN, &gc->gpiodev->descs[offset].flags); + return test_bit(GPIOD_FLAG_OPEN_DRAIN, &gc->gpiodev->descs[offset].flags); } EXPORT_SYMBOL_GPL(gpiochip_line_is_open_drain); =20 @@ -4173,7 +4173,7 @@ bool gpiochip_line_is_open_source(struct gpio_chip *g= c, unsigned int offset) if (offset >=3D gc->ngpio) return false; =20 - return test_bit(FLAG_OPEN_SOURCE, &gc->gpiodev->descs[offset].flags); + return test_bit(GPIOD_FLAG_OPEN_SOURCE, &gc->gpiodev->descs[offset].flags= ); } EXPORT_SYMBOL_GPL(gpiochip_line_is_open_source); =20 @@ -4182,7 +4182,7 @@ bool gpiochip_line_is_persistent(struct gpio_chip *gc= , unsigned int offset) if (offset >=3D gc->ngpio) return false; =20 - return !test_bit(FLAG_TRANSITORY, &gc->gpiodev->descs[offset].flags); + return !test_bit(GPIOD_FLAG_TRANSITORY, &gc->gpiodev->descs[offset].flags= ); } EXPORT_SYMBOL_GPL(gpiochip_line_is_persistent); =20 @@ -4224,7 +4224,7 @@ int gpiod_get_value_cansleep(const struct gpio_desc *= desc) if (value < 0) return value; =20 - if (test_bit(FLAG_ACTIVE_LOW, &desc->flags)) + if (test_bit(GPIOD_FLAG_ACTIVE_LOW, &desc->flags)) value =3D !value; =20 return value; @@ -4806,10 +4806,10 @@ int gpiod_configure_flags(struct gpio_desc *desc, c= onst char *con_id, int ret; =20 if (lflags & GPIO_ACTIVE_LOW) - set_bit(FLAG_ACTIVE_LOW, &desc->flags); + set_bit(GPIOD_FLAG_ACTIVE_LOW, &desc->flags); =20 if (lflags & GPIO_OPEN_DRAIN) - set_bit(FLAG_OPEN_DRAIN, &desc->flags); + set_bit(GPIOD_FLAG_OPEN_DRAIN, &desc->flags); else if (dflags & GPIOD_FLAGS_BIT_OPEN_DRAIN) { /* * This enforces open drain mode from the consumer side. @@ -4817,13 +4817,13 @@ int gpiod_configure_flags(struct gpio_desc *desc, c= onst char *con_id, * should *REALLY* have specified them as open drain in the * first place, so print a little warning here. */ - set_bit(FLAG_OPEN_DRAIN, &desc->flags); + set_bit(GPIOD_FLAG_OPEN_DRAIN, &desc->flags); gpiod_warn(desc, "enforced open drain please flag it properly in DT/ACPI DSDT/board f= ile\n"); } =20 if (lflags & GPIO_OPEN_SOURCE) - set_bit(FLAG_OPEN_SOURCE, &desc->flags); + set_bit(GPIOD_FLAG_OPEN_SOURCE, &desc->flags); =20 if (((lflags & GPIO_PULL_UP) && (lflags & GPIO_PULL_DOWN)) || ((lflags & GPIO_PULL_UP) && (lflags & GPIO_PULL_DISABLE)) || @@ -4834,11 +4834,11 @@ int gpiod_configure_flags(struct gpio_desc *desc, c= onst char *con_id, } =20 if (lflags & GPIO_PULL_UP) - set_bit(FLAG_PULL_UP, &desc->flags); + set_bit(GPIOD_FLAG_PULL_UP, &desc->flags); else if (lflags & GPIO_PULL_DOWN) - set_bit(FLAG_PULL_DOWN, &desc->flags); + set_bit(GPIOD_FLAG_PULL_DOWN, &desc->flags); else if (lflags & GPIO_PULL_DISABLE) - set_bit(FLAG_BIAS_DISABLE, &desc->flags); + set_bit(GPIOD_FLAG_BIAS_DISABLE, &desc->flags); =20 ret =3D gpiod_set_transitory(desc, (lflags & GPIO_TRANSITORY)); if (ret < 0) @@ -4943,7 +4943,7 @@ int gpiod_hog(struct gpio_desc *desc, const char *nam= e, if (!guard.gc) return -ENODEV; =20 - if (test_and_set_bit(FLAG_IS_HOGGED, &desc->flags)) + if (test_and_set_bit(GPIOD_FLAG_IS_HOGGED, &desc->flags)) return 0; =20 hwnum =3D gpio_chip_hwgpio(desc); @@ -4951,7 +4951,7 @@ int gpiod_hog(struct gpio_desc *desc, const char *nam= e, local_desc =3D gpiochip_request_own_desc(guard.gc, hwnum, name, lflags, dflags); if (IS_ERR(local_desc)) { - clear_bit(FLAG_IS_HOGGED, &desc->flags); + clear_bit(GPIOD_FLAG_IS_HOGGED, &desc->flags); ret =3D PTR_ERR(local_desc); pr_err("requesting hog GPIO %s (chip %s, offset %d) failed, %d\n", name, gdev->label, hwnum, ret); @@ -4974,7 +4974,7 @@ static void gpiochip_free_hogs(struct gpio_chip *gc) { struct gpio_desc *desc; =20 - for_each_gpio_desc_with_flag(gc, desc, FLAG_IS_HOGGED) + for_each_gpio_desc_with_flag(gc, desc, GPIOD_FLAG_IS_HOGGED) gpiochip_free_own_desc(desc); } =20 @@ -5089,8 +5089,8 @@ struct gpio_descs *__must_check gpiod_get_array(struc= t device *dev, } else { dflags =3D READ_ONCE(desc->flags); /* Exclude open drain or open source from fast output */ - if (test_bit(FLAG_OPEN_DRAIN, &dflags) || - test_bit(FLAG_OPEN_SOURCE, &dflags)) + if (test_bit(GPIOD_FLAG_OPEN_DRAIN, &dflags) || + test_bit(GPIOD_FLAG_OPEN_SOURCE, &dflags)) __clear_bit(descs->ndescs, array_info->set_mask); /* Identify 'fast' pins which require invertion */ @@ -5248,12 +5248,12 @@ static void gpiolib_dbg_show(struct seq_file *s, st= ruct gpio_device *gdev) for_each_gpio_desc(gc, desc) { guard(srcu)(&desc->gdev->desc_srcu); flags =3D READ_ONCE(desc->flags); - is_irq =3D test_bit(FLAG_USED_AS_IRQ, &flags); - if (is_irq || test_bit(FLAG_REQUESTED, &flags)) { + is_irq =3D test_bit(GPIOD_FLAG_USED_AS_IRQ, &flags); + if (is_irq || test_bit(GPIOD_FLAG_REQUESTED, &flags)) { gpiod_get_direction(desc); - is_out =3D test_bit(FLAG_IS_OUT, &flags); + is_out =3D test_bit(GPIOD_FLAG_IS_OUT, &flags); value =3D gpio_chip_get_value(gc, desc); - active_low =3D test_bit(FLAG_ACTIVE_LOW, &flags); + active_low =3D test_bit(GPIOD_FLAG_ACTIVE_LOW, &flags); seq_printf(s, " gpio-%-3u (%-20.20s|%-20.20s) %s %s %s%s\n", gpio, desc->name ?: "", gpiod_get_label(desc), is_out ? "out" : "in ", diff --git a/drivers/gpio/gpiolib.h b/drivers/gpio/gpiolib.h index 9b74738a9ca5b1a4826c8d56d871f8a7cf6ea1e7..2a003a7311e7ac5beeaa1c947d9= 21149ad991acf 100644 --- a/drivers/gpio/gpiolib.h +++ b/drivers/gpio/gpiolib.h @@ -186,24 +186,24 @@ struct gpio_desc { struct gpio_device *gdev; unsigned long flags; /* flag symbols are bit numbers */ -#define FLAG_REQUESTED 0 -#define FLAG_IS_OUT 1 -#define FLAG_EXPORT 2 /* protected by sysfs_lock */ -#define FLAG_SYSFS 3 /* exported via /sys/class/gpio/control */ -#define FLAG_ACTIVE_LOW 6 /* value has active low */ -#define FLAG_OPEN_DRAIN 7 /* Gpio is open drain type */ -#define FLAG_OPEN_SOURCE 8 /* Gpio is open source type */ -#define FLAG_USED_AS_IRQ 9 /* GPIO is connected to an IRQ */ -#define FLAG_IRQ_IS_ENABLED 10 /* GPIO is connected to an enabled IRQ */ -#define FLAG_IS_HOGGED 11 /* GPIO is hogged */ -#define FLAG_TRANSITORY 12 /* GPIO may lose value in sleep or reset */ -#define FLAG_PULL_UP 13 /* GPIO has pull up enabled */ -#define FLAG_PULL_DOWN 14 /* GPIO has pull down enabled */ -#define FLAG_BIAS_DISABLE 15 /* GPIO has pull disabled */ -#define FLAG_EDGE_RISING 16 /* GPIO CDEV detects rising edge events */ -#define FLAG_EDGE_FALLING 17 /* GPIO CDEV detects falling edge events */ -#define FLAG_EVENT_CLOCK_REALTIME 18 /* GPIO CDEV reports REALTIME timesta= mps in events */ -#define FLAG_EVENT_CLOCK_HTE 19 /* GPIO CDEV reports hardware timestamps = in events */ +#define GPIOD_FLAG_REQUESTED 0 /* GPIO is in use */ +#define GPIOD_FLAG_IS_OUT 1 /* GPIO is in output mode */ +#define GPIOD_FLAG_EXPORT 2 /* GPIO is exported to user-space */ +#define GPIOD_FLAG_SYSFS 3 /* GPIO is exported via /sys/class/gpio */ +#define GPIOD_FLAG_ACTIVE_LOW 6 /* GPIO is active-low */ +#define GPIOD_FLAG_OPEN_DRAIN 7 /* GPIO is open drain type */ +#define GPIOD_FLAG_OPEN_SOURCE 8 /* GPIO is open source type */ +#define GPIOD_FLAG_USED_AS_IRQ 9 /* GPIO is connected to an IRQ */ +#define GPIOD_FLAG_IRQ_IS_ENABLED 10 /* GPIO is connected to an enabled IR= Q */ +#define GPIOD_FLAG_IS_HOGGED 11 /* GPIO is hogged */ +#define GPIOD_FLAG_TRANSITORY 12 /* GPIO may lose value in sleep or reset= */ +#define GPIOD_FLAG_PULL_UP 13 /* GPIO has pull up enabled */ +#define GPIOD_FLAG_PULL_DOWN 14 /* GPIO has pull down enabled */ +#define GPIOD_FLAG_BIAS_DISABLE 15 /* GPIO has pull disabled */ +#define GPIOD_FLAG_EDGE_RISING 16 /* GPIO CDEV detects rising edge events= */ +#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 */ =20 /* Connection label */ struct gpio_desc_label __rcu *label; --- base-commit: 65dd046ef55861190ecde44c6d9fcde54b9fb77d change-id: 20250909-rename-gpio-flags-59f8a7bf60d5 Best regards, --=20 Bartosz Golaszewski