Skip to content

Commit 571c65b

Browse files
author
Bartosz Golaszewski
committed
gpiolib: add a common prefix to GPIO descriptor flags
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. Reviewed-by: Linus Walleij <linus.walleij@linaro.org> Link: https://lore.kernel.org/r/20250909-rename-gpio-flags-v1-1-bda208a40856@linaro.org Signed-off-by: Bartosz Golaszewski <bartosz.golaszewski@linaro.org>
1 parent 7eee64e commit 571c65b

5 files changed

Lines changed: 170 additions & 170 deletions

File tree

‎drivers/gpio/gpiolib-cdev.c‎

Lines changed: 45 additions & 45 deletions
Original file line numberDiff line numberDiff line change
@@ -144,17 +144,17 @@ static void linehandle_flags_to_desc_flags(u32 lflags, unsigned long *flagsp)
144144
{
145145
unsigned long flags = READ_ONCE(*flagsp);
146146

147-
assign_bit(FLAG_ACTIVE_LOW, &flags,
147+
assign_bit(GPIOD_FLAG_ACTIVE_LOW, &flags,
148148
lflags & GPIOHANDLE_REQUEST_ACTIVE_LOW);
149-
assign_bit(FLAG_OPEN_DRAIN, &flags,
149+
assign_bit(GPIOD_FLAG_OPEN_DRAIN, &flags,
150150
lflags & GPIOHANDLE_REQUEST_OPEN_DRAIN);
151-
assign_bit(FLAG_OPEN_SOURCE, &flags,
151+
assign_bit(GPIOD_FLAG_OPEN_SOURCE, &flags,
152152
lflags & GPIOHANDLE_REQUEST_OPEN_SOURCE);
153-
assign_bit(FLAG_PULL_UP, &flags,
153+
assign_bit(GPIOD_FLAG_PULL_UP, &flags,
154154
lflags & GPIOHANDLE_REQUEST_BIAS_PULL_UP);
155-
assign_bit(FLAG_PULL_DOWN, &flags,
155+
assign_bit(GPIOD_FLAG_PULL_DOWN, &flags,
156156
lflags & GPIOHANDLE_REQUEST_BIAS_PULL_DOWN);
157-
assign_bit(FLAG_BIAS_DISABLE, &flags,
157+
assign_bit(GPIOD_FLAG_BIAS_DISABLE, &flags,
158158
lflags & GPIOHANDLE_REQUEST_BIAS_DISABLE);
159159

160160
WRITE_ONCE(*flagsp, flags);
@@ -238,7 +238,7 @@ static long linehandle_ioctl(struct file *file, unsigned int cmd,
238238
* All line descriptors were created at once with the same
239239
* flags so just check if the first one is really output.
240240
*/
241-
if (!test_bit(FLAG_IS_OUT, &lh->descs[0]->flags))
241+
if (!test_bit(GPIOD_FLAG_IS_OUT, &lh->descs[0]->flags))
242242
return -EPERM;
243243

244244
if (copy_from_user(&ghd, ip, sizeof(ghd)))
@@ -599,10 +599,10 @@ static void linereq_put_event(struct linereq *lr,
599599

600600
static u64 line_event_timestamp(struct line *line)
601601
{
602-
if (test_bit(FLAG_EVENT_CLOCK_REALTIME, &line->desc->flags))
602+
if (test_bit(GPIOD_FLAG_EVENT_CLOCK_REALTIME, &line->desc->flags))
603603
return ktime_get_real_ns();
604604
else if (IS_ENABLED(CONFIG_HTE) &&
605-
test_bit(FLAG_EVENT_CLOCK_HTE, &line->desc->flags))
605+
test_bit(GPIOD_FLAG_EVENT_CLOCK_HTE, &line->desc->flags))
606606
return line->timestamp_ns;
607607

608608
return ktime_get_ns();
@@ -725,11 +725,11 @@ static int hte_edge_setup(struct line *line, u64 eflags)
725725
struct hte_ts_desc *hdesc = &line->hdesc;
726726

727727
if (eflags & GPIO_V2_LINE_FLAG_EDGE_RISING)
728-
flags |= test_bit(FLAG_ACTIVE_LOW, &line->desc->flags) ?
728+
flags |= test_bit(GPIOD_FLAG_ACTIVE_LOW, &line->desc->flags) ?
729729
HTE_FALLING_EDGE_TS :
730730
HTE_RISING_EDGE_TS;
731731
if (eflags & GPIO_V2_LINE_FLAG_EDGE_FALLING)
732-
flags |= test_bit(FLAG_ACTIVE_LOW, &line->desc->flags) ?
732+
flags |= test_bit(GPIOD_FLAG_ACTIVE_LOW, &line->desc->flags) ?
733733
HTE_RISING_EDGE_TS :
734734
HTE_FALLING_EDGE_TS;
735735

@@ -831,7 +831,7 @@ static bool debounced_value(struct line *line)
831831
*/
832832
value = READ_ONCE(line->level);
833833

834-
if (test_bit(FLAG_ACTIVE_LOW, &line->desc->flags))
834+
if (test_bit(GPIOD_FLAG_ACTIVE_LOW, &line->desc->flags))
835835
value = !value;
836836

837837
return value;
@@ -939,7 +939,7 @@ static int debounce_setup(struct line *line, unsigned int debounce_period_us)
939939
return level;
940940

941941
if (!(IS_ENABLED(CONFIG_HTE) &&
942-
test_bit(FLAG_EVENT_CLOCK_HTE, &line->desc->flags))) {
942+
test_bit(GPIOD_FLAG_EVENT_CLOCK_HTE, &line->desc->flags))) {
943943
irq = gpiod_to_irq(line->desc);
944944
if (irq < 0)
945945
return -ENXIO;
@@ -1061,10 +1061,10 @@ static int edge_detector_setup(struct line *line,
10611061
return -ENXIO;
10621062

10631063
if (eflags & GPIO_V2_LINE_FLAG_EDGE_RISING)
1064-
irqflags |= test_bit(FLAG_ACTIVE_LOW, &line->desc->flags) ?
1064+
irqflags |= test_bit(GPIOD_FLAG_ACTIVE_LOW, &line->desc->flags) ?
10651065
IRQF_TRIGGER_FALLING : IRQF_TRIGGER_RISING;
10661066
if (eflags & GPIO_V2_LINE_FLAG_EDGE_FALLING)
1067-
irqflags |= test_bit(FLAG_ACTIVE_LOW, &line->desc->flags) ?
1067+
irqflags |= test_bit(GPIOD_FLAG_ACTIVE_LOW, &line->desc->flags) ?
10681068
IRQF_TRIGGER_RISING : IRQF_TRIGGER_FALLING;
10691069
irqflags |= IRQF_ONESHOT;
10701070

@@ -1237,34 +1237,34 @@ static void gpio_v2_line_config_flags_to_desc_flags(u64 lflags,
12371237
{
12381238
unsigned long flags = READ_ONCE(*flagsp);
12391239

1240-
assign_bit(FLAG_ACTIVE_LOW, &flags,
1240+
assign_bit(GPIOD_FLAG_ACTIVE_LOW, &flags,
12411241
lflags & GPIO_V2_LINE_FLAG_ACTIVE_LOW);
12421242

12431243
if (lflags & GPIO_V2_LINE_FLAG_OUTPUT)
1244-
set_bit(FLAG_IS_OUT, &flags);
1244+
set_bit(GPIOD_FLAG_IS_OUT, &flags);
12451245
else if (lflags & GPIO_V2_LINE_FLAG_INPUT)
1246-
clear_bit(FLAG_IS_OUT, &flags);
1246+
clear_bit(GPIOD_FLAG_IS_OUT, &flags);
12471247

1248-
assign_bit(FLAG_EDGE_RISING, &flags,
1248+
assign_bit(GPIOD_FLAG_EDGE_RISING, &flags,
12491249
lflags & GPIO_V2_LINE_FLAG_EDGE_RISING);
1250-
assign_bit(FLAG_EDGE_FALLING, &flags,
1250+
assign_bit(GPIOD_FLAG_EDGE_FALLING, &flags,
12511251
lflags & GPIO_V2_LINE_FLAG_EDGE_FALLING);
12521252

1253-
assign_bit(FLAG_OPEN_DRAIN, &flags,
1253+
assign_bit(GPIOD_FLAG_OPEN_DRAIN, &flags,
12541254
lflags & GPIO_V2_LINE_FLAG_OPEN_DRAIN);
1255-
assign_bit(FLAG_OPEN_SOURCE, &flags,
1255+
assign_bit(GPIOD_FLAG_OPEN_SOURCE, &flags,
12561256
lflags & GPIO_V2_LINE_FLAG_OPEN_SOURCE);
12571257

1258-
assign_bit(FLAG_PULL_UP, &flags,
1258+
assign_bit(GPIOD_FLAG_PULL_UP, &flags,
12591259
lflags & GPIO_V2_LINE_FLAG_BIAS_PULL_UP);
1260-
assign_bit(FLAG_PULL_DOWN, &flags,
1260+
assign_bit(GPIOD_FLAG_PULL_DOWN, &flags,
12611261
lflags & GPIO_V2_LINE_FLAG_BIAS_PULL_DOWN);
1262-
assign_bit(FLAG_BIAS_DISABLE, &flags,
1262+
assign_bit(GPIOD_FLAG_BIAS_DISABLE, &flags,
12631263
lflags & GPIO_V2_LINE_FLAG_BIAS_DISABLED);
12641264

1265-
assign_bit(FLAG_EVENT_CLOCK_REALTIME, &flags,
1265+
assign_bit(GPIOD_FLAG_EVENT_CLOCK_REALTIME, &flags,
12661266
lflags & GPIO_V2_LINE_FLAG_EVENT_CLOCK_REALTIME);
1267-
assign_bit(FLAG_EVENT_CLOCK_HTE, &flags,
1267+
assign_bit(GPIOD_FLAG_EVENT_CLOCK_HTE, &flags,
12681268
lflags & GPIO_V2_LINE_FLAG_EVENT_CLOCK_HTE);
12691269

12701270
WRITE_ONCE(*flagsp, flags);
@@ -2115,10 +2115,10 @@ static int lineevent_create(struct gpio_device *gdev, void __user *ip)
21152115
}
21162116

21172117
if (eflags & GPIOEVENT_REQUEST_RISING_EDGE)
2118-
irqflags |= test_bit(FLAG_ACTIVE_LOW, &desc->flags) ?
2118+
irqflags |= test_bit(GPIOD_FLAG_ACTIVE_LOW, &desc->flags) ?
21192119
IRQF_TRIGGER_FALLING : IRQF_TRIGGER_RISING;
21202120
if (eflags & GPIOEVENT_REQUEST_FALLING_EDGE)
2121-
irqflags |= test_bit(FLAG_ACTIVE_LOW, &desc->flags) ?
2121+
irqflags |= test_bit(GPIOD_FLAG_ACTIVE_LOW, &desc->flags) ?
21222122
IRQF_TRIGGER_RISING : IRQF_TRIGGER_FALLING;
21232123
irqflags |= IRQF_ONESHOT;
21242124

@@ -2253,7 +2253,7 @@ static void gpio_desc_to_lineinfo(struct gpio_desc *desc,
22532253

22542254
scoped_guard(srcu, &desc->gdev->desc_srcu) {
22552255
label = gpiod_get_label(desc);
2256-
if (label && test_bit(FLAG_REQUESTED, &dflags))
2256+
if (label && test_bit(GPIOD_FLAG_REQUESTED, &dflags))
22572257
strscpy(info->consumer, label,
22582258
sizeof(info->consumer));
22592259
}
@@ -2270,45 +2270,45 @@ static void gpio_desc_to_lineinfo(struct gpio_desc *desc,
22702270
* The definitive test that a line is available to userspace is to
22712271
* request it.
22722272
*/
2273-
if (test_bit(FLAG_REQUESTED, &dflags) ||
2274-
test_bit(FLAG_IS_HOGGED, &dflags) ||
2275-
test_bit(FLAG_EXPORT, &dflags) ||
2276-
test_bit(FLAG_SYSFS, &dflags) ||
2273+
if (test_bit(GPIOD_FLAG_REQUESTED, &dflags) ||
2274+
test_bit(GPIOD_FLAG_IS_HOGGED, &dflags) ||
2275+
test_bit(GPIOD_FLAG_EXPORT, &dflags) ||
2276+
test_bit(GPIOD_FLAG_SYSFS, &dflags) ||
22772277
!gpiochip_line_is_valid(guard.gc, info->offset)) {
22782278
info->flags |= GPIO_V2_LINE_FLAG_USED;
22792279
} else if (!atomic) {
22802280
if (!pinctrl_gpio_can_use_line(guard.gc, info->offset))
22812281
info->flags |= GPIO_V2_LINE_FLAG_USED;
22822282
}
22832283

2284-
if (test_bit(FLAG_IS_OUT, &dflags))
2284+
if (test_bit(GPIOD_FLAG_IS_OUT, &dflags))
22852285
info->flags |= GPIO_V2_LINE_FLAG_OUTPUT;
22862286
else
22872287
info->flags |= GPIO_V2_LINE_FLAG_INPUT;
22882288

2289-
if (test_bit(FLAG_ACTIVE_LOW, &dflags))
2289+
if (test_bit(GPIOD_FLAG_ACTIVE_LOW, &dflags))
22902290
info->flags |= GPIO_V2_LINE_FLAG_ACTIVE_LOW;
22912291

2292-
if (test_bit(FLAG_OPEN_DRAIN, &dflags))
2292+
if (test_bit(GPIOD_FLAG_OPEN_DRAIN, &dflags))
22932293
info->flags |= GPIO_V2_LINE_FLAG_OPEN_DRAIN;
2294-
if (test_bit(FLAG_OPEN_SOURCE, &dflags))
2294+
if (test_bit(GPIOD_FLAG_OPEN_SOURCE, &dflags))
22952295
info->flags |= GPIO_V2_LINE_FLAG_OPEN_SOURCE;
22962296

2297-
if (test_bit(FLAG_BIAS_DISABLE, &dflags))
2297+
if (test_bit(GPIOD_FLAG_BIAS_DISABLE, &dflags))
22982298
info->flags |= GPIO_V2_LINE_FLAG_BIAS_DISABLED;
2299-
if (test_bit(FLAG_PULL_DOWN, &dflags))
2299+
if (test_bit(GPIOD_FLAG_PULL_DOWN, &dflags))
23002300
info->flags |= GPIO_V2_LINE_FLAG_BIAS_PULL_DOWN;
2301-
if (test_bit(FLAG_PULL_UP, &dflags))
2301+
if (test_bit(GPIOD_FLAG_PULL_UP, &dflags))
23022302
info->flags |= GPIO_V2_LINE_FLAG_BIAS_PULL_UP;
23032303

2304-
if (test_bit(FLAG_EDGE_RISING, &dflags))
2304+
if (test_bit(GPIOD_FLAG_EDGE_RISING, &dflags))
23052305
info->flags |= GPIO_V2_LINE_FLAG_EDGE_RISING;
2306-
if (test_bit(FLAG_EDGE_FALLING, &dflags))
2306+
if (test_bit(GPIOD_FLAG_EDGE_FALLING, &dflags))
23072307
info->flags |= GPIO_V2_LINE_FLAG_EDGE_FALLING;
23082308

2309-
if (test_bit(FLAG_EVENT_CLOCK_REALTIME, &dflags))
2309+
if (test_bit(GPIOD_FLAG_EVENT_CLOCK_REALTIME, &dflags))
23102310
info->flags |= GPIO_V2_LINE_FLAG_EVENT_CLOCK_REALTIME;
2311-
else if (test_bit(FLAG_EVENT_CLOCK_HTE, &dflags))
2311+
else if (test_bit(GPIOD_FLAG_EVENT_CLOCK_HTE, &dflags))
23122312
info->flags |= GPIO_V2_LINE_FLAG_EVENT_CLOCK_HTE;
23132313

23142314
debounce_period_us = READ_ONCE(desc->debounce_period_us);

‎drivers/gpio/gpiolib-of.c‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -878,7 +878,7 @@ static void of_gpiochip_remove_hog(struct gpio_chip *chip,
878878
{
879879
struct gpio_desc *desc;
880880

881-
for_each_gpio_desc_with_flag(chip, desc, FLAG_IS_HOGGED)
881+
for_each_gpio_desc_with_flag(chip, desc, GPIOD_FLAG_IS_HOGGED)
882882
if (READ_ONCE(desc->hog) == hog)
883883
gpiochip_free_own_desc(desc);
884884
}

‎drivers/gpio/gpiolib-sysfs.c‎

Lines changed: 23 additions & 23 deletions
Original file line numberDiff line numberDiff line change
@@ -131,7 +131,7 @@ static ssize_t direction_show(struct device *dev,
131131

132132
scoped_guard(mutex, &data->mutex) {
133133
gpiod_get_direction(desc);
134-
value = !!test_bit(FLAG_IS_OUT, &desc->flags);
134+
value = !!test_bit(GPIOD_FLAG_IS_OUT, &desc->flags);
135135
}
136136

137137
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)
226226

227227
irq_flags = IRQF_SHARED;
228228
if (flags & GPIO_IRQF_TRIGGER_FALLING) {
229-
irq_flags |= test_bit(FLAG_ACTIVE_LOW, &desc->flags) ?
229+
irq_flags |= test_bit(GPIOD_FLAG_ACTIVE_LOW, &desc->flags) ?
230230
IRQF_TRIGGER_RISING : IRQF_TRIGGER_FALLING;
231-
set_bit(FLAG_EDGE_FALLING, &desc->flags);
231+
set_bit(GPIOD_FLAG_EDGE_FALLING, &desc->flags);
232232
}
233233
if (flags & GPIO_IRQF_TRIGGER_RISING) {
234-
irq_flags |= test_bit(FLAG_ACTIVE_LOW, &desc->flags) ?
234+
irq_flags |= test_bit(GPIOD_FLAG_ACTIVE_LOW, &desc->flags) ?
235235
IRQF_TRIGGER_FALLING : IRQF_TRIGGER_RISING;
236-
set_bit(FLAG_EDGE_RISING, &desc->flags);
236+
set_bit(GPIOD_FLAG_EDGE_RISING, &desc->flags);
237237
}
238238

239239
/*
@@ -260,8 +260,8 @@ static int gpio_sysfs_request_irq(struct gpiod_data *data, unsigned char flags)
260260
err_unlock:
261261
gpiochip_unlock_as_irq(guard.gc, gpio_chip_hwgpio(desc));
262262
err_clr_bits:
263-
clear_bit(FLAG_EDGE_RISING, &desc->flags);
264-
clear_bit(FLAG_EDGE_FALLING, &desc->flags);
263+
clear_bit(GPIOD_FLAG_EDGE_RISING, &desc->flags);
264+
clear_bit(GPIOD_FLAG_EDGE_FALLING, &desc->flags);
265265

266266
return ret;
267267
}
@@ -281,8 +281,8 @@ static void gpio_sysfs_free_irq(struct gpiod_data *data)
281281
data->irq_flags = 0;
282282
free_irq(data->irq, data);
283283
gpiochip_unlock_as_irq(guard.gc, gpio_chip_hwgpio(desc));
284-
clear_bit(FLAG_EDGE_RISING, &desc->flags);
285-
clear_bit(FLAG_EDGE_FALLING, &desc->flags);
284+
clear_bit(GPIOD_FLAG_EDGE_RISING, &desc->flags);
285+
clear_bit(GPIOD_FLAG_EDGE_FALLING, &desc->flags);
286286
}
287287

288288
static const char *const trigger_names[] = {
@@ -347,10 +347,10 @@ static int gpio_sysfs_set_active_low(struct gpiod_data *data, int value)
347347
struct gpio_desc *desc = data->desc;
348348
int status = 0;
349349

350-
if (!!test_bit(FLAG_ACTIVE_LOW, &desc->flags) == !!value)
350+
if (!!test_bit(GPIOD_FLAG_ACTIVE_LOW, &desc->flags) == !!value)
351351
return 0;
352352

353-
assign_bit(FLAG_ACTIVE_LOW, &desc->flags, value);
353+
assign_bit(GPIOD_FLAG_ACTIVE_LOW, &desc->flags, value);
354354

355355
/* reconfigure poll(2) support if enabled on one edge only */
356356
if (flags == GPIO_IRQF_TRIGGER_FALLING ||
@@ -373,7 +373,7 @@ static ssize_t active_low_show(struct device *dev,
373373
int value;
374374

375375
scoped_guard(mutex, &data->mutex)
376-
value = !!test_bit(FLAG_ACTIVE_LOW, &desc->flags);
376+
value = !!test_bit(GPIOD_FLAG_ACTIVE_LOW, &desc->flags);
377377

378378
return sysfs_emit(buf, "%d\n", value);
379379
}
@@ -418,7 +418,7 @@ static umode_t gpio_is_visible(struct kobject *kobj, struct attribute *attr,
418418
mode = 0;
419419

420420
if (!data->direction_can_change &&
421-
test_bit(FLAG_IS_OUT, &data->desc->flags))
421+
test_bit(GPIOD_FLAG_IS_OUT, &data->desc->flags))
422422
mode = 0;
423423
#endif /* CONFIG_GPIO_SYSFS_LEGACY */
424424
}
@@ -486,7 +486,7 @@ static int export_gpio_desc(struct gpio_desc *desc)
486486
}
487487

488488
/*
489-
* No extra locking here; FLAG_SYSFS just signifies that the
489+
* No extra locking here; GPIOD_FLAG_SYSFS just signifies that the
490490
* request and export were done by on behalf of userspace, so
491491
* they may be undone on its behalf too.
492492
*/
@@ -505,7 +505,7 @@ static int export_gpio_desc(struct gpio_desc *desc)
505505
if (ret < 0) {
506506
gpiod_free(desc);
507507
} else {
508-
set_bit(FLAG_SYSFS, &desc->flags);
508+
set_bit(GPIOD_FLAG_SYSFS, &desc->flags);
509509
gpiod_line_state_notify(desc, GPIO_V2_LINE_CHANGED_REQUESTED);
510510
}
511511

@@ -515,11 +515,11 @@ static int export_gpio_desc(struct gpio_desc *desc)
515515
static int unexport_gpio_desc(struct gpio_desc *desc)
516516
{
517517
/*
518-
* No extra locking here; FLAG_SYSFS just signifies that the
518+
* No extra locking here; GPIOD_FLAG_SYSFS just signifies that the
519519
* request and export were done by on behalf of userspace, so
520520
* they may be undone on its behalf too.
521521
*/
522-
if (!test_and_clear_bit(FLAG_SYSFS, &desc->flags))
522+
if (!test_and_clear_bit(GPIOD_FLAG_SYSFS, &desc->flags))
523523
return -EINVAL;
524524

525525
gpiod_unexport(desc);
@@ -748,14 +748,14 @@ int gpiod_export(struct gpio_desc *desc, bool direction_may_change)
748748
if (!guard.gc)
749749
return -ENODEV;
750750

751-
if (test_and_set_bit(FLAG_EXPORT, &desc->flags))
751+
if (test_and_set_bit(GPIOD_FLAG_EXPORT, &desc->flags))
752752
return -EPERM;
753753

754754
gdev = desc->gdev;
755755

756756
guard(mutex)(&sysfs_lock);
757757

758-
if (!test_bit(FLAG_REQUESTED, &desc->flags)) {
758+
if (!test_bit(GPIOD_FLAG_REQUESTED, &desc->flags)) {
759759
gpiod_dbg(desc, "%s: unavailable (not requested)\n", __func__);
760760
status = -EPERM;
761761
goto err_clear_bit;
@@ -866,7 +866,7 @@ int gpiod_export(struct gpio_desc *desc, bool direction_may_change)
866866
#endif /* CONFIG_GPIO_SYSFS_LEGACY */
867867
kfree(desc_data);
868868
err_clear_bit:
869-
clear_bit(FLAG_EXPORT, &desc->flags);
869+
clear_bit(GPIOD_FLAG_EXPORT, &desc->flags);
870870
gpiod_dbg(desc, "%s: status %d\n", __func__, status);
871871
return status;
872872
}
@@ -937,7 +937,7 @@ void gpiod_unexport(struct gpio_desc *desc)
937937
}
938938

939939
scoped_guard(mutex, &sysfs_lock) {
940-
if (!test_bit(FLAG_EXPORT, &desc->flags))
940+
if (!test_bit(GPIOD_FLAG_EXPORT, &desc->flags))
941941
return;
942942

943943
gdev = gpiod_to_gpio_device(desc);
@@ -956,7 +956,7 @@ void gpiod_unexport(struct gpio_desc *desc)
956956
return;
957957

958958
list_del(&desc_data->list);
959-
clear_bit(FLAG_EXPORT, &desc->flags);
959+
clear_bit(GPIOD_FLAG_EXPORT, &desc->flags);
960960
#if IS_ENABLED(CONFIG_GPIO_SYSFS_LEGACY)
961961
sysfs_put(desc_data->value_kn);
962962
device_unregister(desc_data->dev);
@@ -1073,7 +1073,7 @@ void gpiochip_sysfs_unregister(struct gpio_device *gdev)
10731073
return;
10741074

10751075
/* unregister gpiod class devices owned by sysfs */
1076-
for_each_gpio_desc_with_flag(chip, desc, FLAG_SYSFS) {
1076+
for_each_gpio_desc_with_flag(chip, desc, GPIOD_FLAG_SYSFS) {
10771077
gpiod_unexport(desc);
10781078
gpiod_free(desc);
10791079
}

0 commit comments

Comments
 (0)