tjh.dev / kernel
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
1
fork

Configure Feed

Select the types of activity you want to include in your feed.

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>

Bartosz Golaszewski 571c65bb 7eee64e8

+170 -170
+45 -45
drivers/gpio/gpiolib-cdev.c
··· 144 144 { 145 145 unsigned long flags = READ_ONCE(*flagsp); 146 146 147 - assign_bit(FLAG_ACTIVE_LOW, &flags, 147 + assign_bit(GPIOD_FLAG_ACTIVE_LOW, &flags, 148 148 lflags & GPIOHANDLE_REQUEST_ACTIVE_LOW); 149 - assign_bit(FLAG_OPEN_DRAIN, &flags, 149 + assign_bit(GPIOD_FLAG_OPEN_DRAIN, &flags, 150 150 lflags & GPIOHANDLE_REQUEST_OPEN_DRAIN); 151 - assign_bit(FLAG_OPEN_SOURCE, &flags, 151 + assign_bit(GPIOD_FLAG_OPEN_SOURCE, &flags, 152 152 lflags & GPIOHANDLE_REQUEST_OPEN_SOURCE); 153 - assign_bit(FLAG_PULL_UP, &flags, 153 + assign_bit(GPIOD_FLAG_PULL_UP, &flags, 154 154 lflags & GPIOHANDLE_REQUEST_BIAS_PULL_UP); 155 - assign_bit(FLAG_PULL_DOWN, &flags, 155 + assign_bit(GPIOD_FLAG_PULL_DOWN, &flags, 156 156 lflags & GPIOHANDLE_REQUEST_BIAS_PULL_DOWN); 157 - assign_bit(FLAG_BIAS_DISABLE, &flags, 157 + assign_bit(GPIOD_FLAG_BIAS_DISABLE, &flags, 158 158 lflags & GPIOHANDLE_REQUEST_BIAS_DISABLE); 159 159 160 160 WRITE_ONCE(*flagsp, flags); ··· 238 238 * All line descriptors were created at once with the same 239 239 * flags so just check if the first one is really output. 240 240 */ 241 - if (!test_bit(FLAG_IS_OUT, &lh->descs[0]->flags)) 241 + if (!test_bit(GPIOD_FLAG_IS_OUT, &lh->descs[0]->flags)) 242 242 return -EPERM; 243 243 244 244 if (copy_from_user(&ghd, ip, sizeof(ghd))) ··· 599 599 600 600 static u64 line_event_timestamp(struct line *line) 601 601 { 602 - if (test_bit(FLAG_EVENT_CLOCK_REALTIME, &line->desc->flags)) 602 + if (test_bit(GPIOD_FLAG_EVENT_CLOCK_REALTIME, &line->desc->flags)) 603 603 return ktime_get_real_ns(); 604 604 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)) 606 606 return line->timestamp_ns; 607 607 608 608 return ktime_get_ns(); ··· 725 725 struct hte_ts_desc *hdesc = &line->hdesc; 726 726 727 727 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) ? 729 729 HTE_FALLING_EDGE_TS : 730 730 HTE_RISING_EDGE_TS; 731 731 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) ? 733 733 HTE_RISING_EDGE_TS : 734 734 HTE_FALLING_EDGE_TS; 735 735 ··· 831 831 */ 832 832 value = READ_ONCE(line->level); 833 833 834 - if (test_bit(FLAG_ACTIVE_LOW, &line->desc->flags)) 834 + if (test_bit(GPIOD_FLAG_ACTIVE_LOW, &line->desc->flags)) 835 835 value = !value; 836 836 837 837 return value; ··· 939 939 return level; 940 940 941 941 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))) { 943 943 irq = gpiod_to_irq(line->desc); 944 944 if (irq < 0) 945 945 return -ENXIO; ··· 1061 1061 return -ENXIO; 1062 1062 1063 1063 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) ? 1065 1065 IRQF_TRIGGER_FALLING : IRQF_TRIGGER_RISING; 1066 1066 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) ? 1068 1068 IRQF_TRIGGER_RISING : IRQF_TRIGGER_FALLING; 1069 1069 irqflags |= IRQF_ONESHOT; 1070 1070 ··· 1237 1237 { 1238 1238 unsigned long flags = READ_ONCE(*flagsp); 1239 1239 1240 - assign_bit(FLAG_ACTIVE_LOW, &flags, 1240 + assign_bit(GPIOD_FLAG_ACTIVE_LOW, &flags, 1241 1241 lflags & GPIO_V2_LINE_FLAG_ACTIVE_LOW); 1242 1242 1243 1243 if (lflags & GPIO_V2_LINE_FLAG_OUTPUT) 1244 - set_bit(FLAG_IS_OUT, &flags); 1244 + set_bit(GPIOD_FLAG_IS_OUT, &flags); 1245 1245 else if (lflags & GPIO_V2_LINE_FLAG_INPUT) 1246 - clear_bit(FLAG_IS_OUT, &flags); 1246 + clear_bit(GPIOD_FLAG_IS_OUT, &flags); 1247 1247 1248 - assign_bit(FLAG_EDGE_RISING, &flags, 1248 + assign_bit(GPIOD_FLAG_EDGE_RISING, &flags, 1249 1249 lflags & GPIO_V2_LINE_FLAG_EDGE_RISING); 1250 - assign_bit(FLAG_EDGE_FALLING, &flags, 1250 + assign_bit(GPIOD_FLAG_EDGE_FALLING, &flags, 1251 1251 lflags & GPIO_V2_LINE_FLAG_EDGE_FALLING); 1252 1252 1253 - assign_bit(FLAG_OPEN_DRAIN, &flags, 1253 + assign_bit(GPIOD_FLAG_OPEN_DRAIN, &flags, 1254 1254 lflags & GPIO_V2_LINE_FLAG_OPEN_DRAIN); 1255 - assign_bit(FLAG_OPEN_SOURCE, &flags, 1255 + assign_bit(GPIOD_FLAG_OPEN_SOURCE, &flags, 1256 1256 lflags & GPIO_V2_LINE_FLAG_OPEN_SOURCE); 1257 1257 1258 - assign_bit(FLAG_PULL_UP, &flags, 1258 + assign_bit(GPIOD_FLAG_PULL_UP, &flags, 1259 1259 lflags & GPIO_V2_LINE_FLAG_BIAS_PULL_UP); 1260 - assign_bit(FLAG_PULL_DOWN, &flags, 1260 + assign_bit(GPIOD_FLAG_PULL_DOWN, &flags, 1261 1261 lflags & GPIO_V2_LINE_FLAG_BIAS_PULL_DOWN); 1262 - assign_bit(FLAG_BIAS_DISABLE, &flags, 1262 + assign_bit(GPIOD_FLAG_BIAS_DISABLE, &flags, 1263 1263 lflags & GPIO_V2_LINE_FLAG_BIAS_DISABLED); 1264 1264 1265 - assign_bit(FLAG_EVENT_CLOCK_REALTIME, &flags, 1265 + assign_bit(GPIOD_FLAG_EVENT_CLOCK_REALTIME, &flags, 1266 1266 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, 1268 1268 lflags & GPIO_V2_LINE_FLAG_EVENT_CLOCK_HTE); 1269 1269 1270 1270 WRITE_ONCE(*flagsp, flags); ··· 2115 2115 } 2116 2116 2117 2117 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) ? 2119 2119 IRQF_TRIGGER_FALLING : IRQF_TRIGGER_RISING; 2120 2120 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) ? 2122 2122 IRQF_TRIGGER_RISING : IRQF_TRIGGER_FALLING; 2123 2123 irqflags |= IRQF_ONESHOT; 2124 2124 ··· 2253 2253 2254 2254 scoped_guard(srcu, &desc->gdev->desc_srcu) { 2255 2255 label = gpiod_get_label(desc); 2256 - if (label && test_bit(FLAG_REQUESTED, &dflags)) 2256 + if (label && test_bit(GPIOD_FLAG_REQUESTED, &dflags)) 2257 2257 strscpy(info->consumer, label, 2258 2258 sizeof(info->consumer)); 2259 2259 } ··· 2270 2270 * The definitive test that a line is available to userspace is to 2271 2271 * request it. 2272 2272 */ 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) || 2277 2277 !gpiochip_line_is_valid(guard.gc, info->offset)) { 2278 2278 info->flags |= GPIO_V2_LINE_FLAG_USED; 2279 2279 } else if (!atomic) { ··· 2281 2281 info->flags |= GPIO_V2_LINE_FLAG_USED; 2282 2282 } 2283 2283 2284 - if (test_bit(FLAG_IS_OUT, &dflags)) 2284 + if (test_bit(GPIOD_FLAG_IS_OUT, &dflags)) 2285 2285 info->flags |= GPIO_V2_LINE_FLAG_OUTPUT; 2286 2286 else 2287 2287 info->flags |= GPIO_V2_LINE_FLAG_INPUT; 2288 2288 2289 - if (test_bit(FLAG_ACTIVE_LOW, &dflags)) 2289 + if (test_bit(GPIOD_FLAG_ACTIVE_LOW, &dflags)) 2290 2290 info->flags |= GPIO_V2_LINE_FLAG_ACTIVE_LOW; 2291 2291 2292 - if (test_bit(FLAG_OPEN_DRAIN, &dflags)) 2292 + if (test_bit(GPIOD_FLAG_OPEN_DRAIN, &dflags)) 2293 2293 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)) 2295 2295 info->flags |= GPIO_V2_LINE_FLAG_OPEN_SOURCE; 2296 2296 2297 - if (test_bit(FLAG_BIAS_DISABLE, &dflags)) 2297 + if (test_bit(GPIOD_FLAG_BIAS_DISABLE, &dflags)) 2298 2298 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)) 2300 2300 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)) 2302 2302 info->flags |= GPIO_V2_LINE_FLAG_BIAS_PULL_UP; 2303 2303 2304 - if (test_bit(FLAG_EDGE_RISING, &dflags)) 2304 + if (test_bit(GPIOD_FLAG_EDGE_RISING, &dflags)) 2305 2305 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)) 2307 2307 info->flags |= GPIO_V2_LINE_FLAG_EDGE_FALLING; 2308 2308 2309 - if (test_bit(FLAG_EVENT_CLOCK_REALTIME, &dflags)) 2309 + if (test_bit(GPIOD_FLAG_EVENT_CLOCK_REALTIME, &dflags)) 2310 2310 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)) 2312 2312 info->flags |= GPIO_V2_LINE_FLAG_EVENT_CLOCK_HTE; 2313 2313 2314 2314 debounce_period_us = READ_ONCE(desc->debounce_period_us);
+1 -1
drivers/gpio/gpiolib-of.c
··· 878 878 { 879 879 struct gpio_desc *desc; 880 880 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) 882 882 if (READ_ONCE(desc->hog) == hog) 883 883 gpiochip_free_own_desc(desc); 884 884 }
+23 -23
drivers/gpio/gpiolib-sysfs.c
··· 131 131 132 132 scoped_guard(mutex, &data->mutex) { 133 133 gpiod_get_direction(desc); 134 - value = !!test_bit(FLAG_IS_OUT, &desc->flags); 134 + value = !!test_bit(GPIOD_FLAG_IS_OUT, &desc->flags); 135 135 } 136 136 137 137 return sysfs_emit(buf, "%s\n", value ? "out" : "in"); ··· 226 226 227 227 irq_flags = IRQF_SHARED; 228 228 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) ? 230 230 IRQF_TRIGGER_RISING : IRQF_TRIGGER_FALLING; 231 - set_bit(FLAG_EDGE_FALLING, &desc->flags); 231 + set_bit(GPIOD_FLAG_EDGE_FALLING, &desc->flags); 232 232 } 233 233 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) ? 235 235 IRQF_TRIGGER_FALLING : IRQF_TRIGGER_RISING; 236 - set_bit(FLAG_EDGE_RISING, &desc->flags); 236 + set_bit(GPIOD_FLAG_EDGE_RISING, &desc->flags); 237 237 } 238 238 239 239 /* ··· 260 260 err_unlock: 261 261 gpiochip_unlock_as_irq(guard.gc, gpio_chip_hwgpio(desc)); 262 262 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); 265 265 266 266 return ret; 267 267 } ··· 281 281 data->irq_flags = 0; 282 282 free_irq(data->irq, data); 283 283 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); 286 286 } 287 287 288 288 static const char *const trigger_names[] = { ··· 347 347 struct gpio_desc *desc = data->desc; 348 348 int status = 0; 349 349 350 - if (!!test_bit(FLAG_ACTIVE_LOW, &desc->flags) == !!value) 350 + if (!!test_bit(GPIOD_FLAG_ACTIVE_LOW, &desc->flags) == !!value) 351 351 return 0; 352 352 353 - assign_bit(FLAG_ACTIVE_LOW, &desc->flags, value); 353 + assign_bit(GPIOD_FLAG_ACTIVE_LOW, &desc->flags, value); 354 354 355 355 /* reconfigure poll(2) support if enabled on one edge only */ 356 356 if (flags == GPIO_IRQF_TRIGGER_FALLING || ··· 373 373 int value; 374 374 375 375 scoped_guard(mutex, &data->mutex) 376 - value = !!test_bit(FLAG_ACTIVE_LOW, &desc->flags); 376 + value = !!test_bit(GPIOD_FLAG_ACTIVE_LOW, &desc->flags); 377 377 378 378 return sysfs_emit(buf, "%d\n", value); 379 379 } ··· 418 418 mode = 0; 419 419 420 420 if (!data->direction_can_change && 421 - test_bit(FLAG_IS_OUT, &data->desc->flags)) 421 + test_bit(GPIOD_FLAG_IS_OUT, &data->desc->flags)) 422 422 mode = 0; 423 423 #endif /* CONFIG_GPIO_SYSFS_LEGACY */ 424 424 } ··· 486 486 } 487 487 488 488 /* 489 - * No extra locking here; FLAG_SYSFS just signifies that the 489 + * No extra locking here; GPIOD_FLAG_SYSFS just signifies that the 490 490 * request and export were done by on behalf of userspace, so 491 491 * they may be undone on its behalf too. 492 492 */ ··· 505 505 if (ret < 0) { 506 506 gpiod_free(desc); 507 507 } else { 508 - set_bit(FLAG_SYSFS, &desc->flags); 508 + set_bit(GPIOD_FLAG_SYSFS, &desc->flags); 509 509 gpiod_line_state_notify(desc, GPIO_V2_LINE_CHANGED_REQUESTED); 510 510 } 511 511 ··· 515 515 static int unexport_gpio_desc(struct gpio_desc *desc) 516 516 { 517 517 /* 518 - * No extra locking here; FLAG_SYSFS just signifies that the 518 + * No extra locking here; GPIOD_FLAG_SYSFS just signifies that the 519 519 * request and export were done by on behalf of userspace, so 520 520 * they may be undone on its behalf too. 521 521 */ 522 - if (!test_and_clear_bit(FLAG_SYSFS, &desc->flags)) 522 + if (!test_and_clear_bit(GPIOD_FLAG_SYSFS, &desc->flags)) 523 523 return -EINVAL; 524 524 525 525 gpiod_unexport(desc); ··· 748 748 if (!guard.gc) 749 749 return -ENODEV; 750 750 751 - if (test_and_set_bit(FLAG_EXPORT, &desc->flags)) 751 + if (test_and_set_bit(GPIOD_FLAG_EXPORT, &desc->flags)) 752 752 return -EPERM; 753 753 754 754 gdev = desc->gdev; 755 755 756 756 guard(mutex)(&sysfs_lock); 757 757 758 - if (!test_bit(FLAG_REQUESTED, &desc->flags)) { 758 + if (!test_bit(GPIOD_FLAG_REQUESTED, &desc->flags)) { 759 759 gpiod_dbg(desc, "%s: unavailable (not requested)\n", __func__); 760 760 status = -EPERM; 761 761 goto err_clear_bit; ··· 866 866 #endif /* CONFIG_GPIO_SYSFS_LEGACY */ 867 867 kfree(desc_data); 868 868 err_clear_bit: 869 - clear_bit(FLAG_EXPORT, &desc->flags); 869 + clear_bit(GPIOD_FLAG_EXPORT, &desc->flags); 870 870 gpiod_dbg(desc, "%s: status %d\n", __func__, status); 871 871 return status; 872 872 } ··· 937 937 } 938 938 939 939 scoped_guard(mutex, &sysfs_lock) { 940 - if (!test_bit(FLAG_EXPORT, &desc->flags)) 940 + if (!test_bit(GPIOD_FLAG_EXPORT, &desc->flags)) 941 941 return; 942 942 943 943 gdev = gpiod_to_gpio_device(desc); ··· 956 956 return; 957 957 958 958 list_del(&desc_data->list); 959 - clear_bit(FLAG_EXPORT, &desc->flags); 959 + clear_bit(GPIOD_FLAG_EXPORT, &desc->flags); 960 960 #if IS_ENABLED(CONFIG_GPIO_SYSFS_LEGACY) 961 961 sysfs_put(desc_data->value_kn); 962 962 device_unregister(desc_data->dev); ··· 1073 1073 return; 1074 1074 1075 1075 /* 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) { 1077 1077 gpiod_unexport(desc); 1078 1078 gpiod_free(desc); 1079 1079 }
+83 -83
drivers/gpio/gpiolib.c
··· 127 127 label = srcu_dereference_check(desc->label, &desc->gdev->desc_srcu, 128 128 srcu_read_lock_held(&desc->gdev->desc_srcu)); 129 129 130 - if (test_bit(FLAG_USED_AS_IRQ, &flags)) 130 + if (test_bit(GPIOD_FLAG_USED_AS_IRQ, &flags)) 131 131 return label ? label->str : "interrupt"; 132 132 133 - if (!test_bit(FLAG_REQUESTED, &flags)) 133 + if (!test_bit(GPIOD_FLAG_REQUESTED, &flags)) 134 134 return NULL; 135 135 136 136 return label ? label->str : NULL; ··· 450 450 * Open drain emulation using input mode may incorrectly report 451 451 * input here, fix that up. 452 452 */ 453 - if (test_bit(FLAG_OPEN_DRAIN, &flags) && 454 - test_bit(FLAG_IS_OUT, &flags)) 453 + if (test_bit(GPIOD_FLAG_OPEN_DRAIN, &flags) && 454 + test_bit(GPIOD_FLAG_IS_OUT, &flags)) 455 455 return 0; 456 456 457 457 if (!guard.gc->get_direction) ··· 468 468 if (ret > 0) 469 469 ret = 1; 470 470 471 - assign_bit(FLAG_IS_OUT, &flags, !ret); 471 + assign_bit(GPIOD_FLAG_IS_OUT, &flags, !ret); 472 472 WRITE_ONCE(desc->flags, flags); 473 473 474 474 return ret; ··· 846 846 { 847 847 struct gpio_desc *desc; 848 848 849 - for_each_gpio_desc_with_flag(gc, desc, FLAG_USED_AS_IRQ) 849 + for_each_gpio_desc_with_flag(gc, desc, GPIOD_FLAG_USED_AS_IRQ) 850 850 gpiod_free_irqs(desc); 851 851 } 852 852 ··· 1169 1169 * lock here. 1170 1170 */ 1171 1171 if (gc->get_direction && gpiochip_line_is_valid(gc, desc_index)) 1172 - assign_bit(FLAG_IS_OUT, &desc->flags, 1172 + assign_bit(GPIOD_FLAG_IS_OUT, &desc->flags, 1173 1173 !gc->get_direction(gc, desc_index)); 1174 1174 else 1175 - assign_bit(FLAG_IS_OUT, 1175 + assign_bit(GPIOD_FLAG_IS_OUT, 1176 1176 &desc->flags, !gc->direction_input); 1177 1177 } 1178 1178 ··· 2449 2449 if (!guard.gc) 2450 2450 return -ENODEV; 2451 2451 2452 - if (test_and_set_bit(FLAG_REQUESTED, &desc->flags)) 2452 + if (test_and_set_bit(GPIOD_FLAG_REQUESTED, &desc->flags)) 2453 2453 return -EBUSY; 2454 2454 2455 2455 offset = gpio_chip_hwgpio(desc); ··· 2478 2478 return 0; 2479 2479 2480 2480 out_clear_bit: 2481 - clear_bit(FLAG_REQUESTED, &desc->flags); 2481 + clear_bit(GPIOD_FLAG_REQUESTED, &desc->flags); 2482 2482 return ret; 2483 2483 } 2484 2484 ··· 2512 2512 2513 2513 flags = READ_ONCE(desc->flags); 2514 2514 2515 - if (guard.gc && test_bit(FLAG_REQUESTED, &flags)) { 2515 + if (guard.gc && test_bit(GPIOD_FLAG_REQUESTED, &flags)) { 2516 2516 if (guard.gc->free) 2517 2517 guard.gc->free(guard.gc, gpio_chip_hwgpio(desc)); 2518 2518 2519 - clear_bit(FLAG_ACTIVE_LOW, &flags); 2520 - clear_bit(FLAG_REQUESTED, &flags); 2521 - clear_bit(FLAG_OPEN_DRAIN, &flags); 2522 - clear_bit(FLAG_OPEN_SOURCE, &flags); 2523 - clear_bit(FLAG_PULL_UP, &flags); 2524 - clear_bit(FLAG_PULL_DOWN, &flags); 2525 - clear_bit(FLAG_BIAS_DISABLE, &flags); 2526 - clear_bit(FLAG_EDGE_RISING, &flags); 2527 - clear_bit(FLAG_EDGE_FALLING, &flags); 2528 - clear_bit(FLAG_IS_HOGGED, &flags); 2519 + clear_bit(GPIOD_FLAG_ACTIVE_LOW, &flags); 2520 + clear_bit(GPIOD_FLAG_REQUESTED, &flags); 2521 + clear_bit(GPIOD_FLAG_OPEN_DRAIN, &flags); 2522 + clear_bit(GPIOD_FLAG_OPEN_SOURCE, &flags); 2523 + clear_bit(GPIOD_FLAG_PULL_UP, &flags); 2524 + clear_bit(GPIOD_FLAG_PULL_DOWN, &flags); 2525 + clear_bit(GPIOD_FLAG_BIAS_DISABLE, &flags); 2526 + clear_bit(GPIOD_FLAG_EDGE_RISING, &flags); 2527 + clear_bit(GPIOD_FLAG_EDGE_FALLING, &flags); 2528 + clear_bit(GPIOD_FLAG_IS_HOGGED, &flags); 2529 2529 #ifdef CONFIG_OF_DYNAMIC 2530 2530 WRITE_ONCE(desc->hog, NULL); 2531 2531 #endif ··· 2568 2568 if (IS_ERR(desc)) 2569 2569 return NULL; 2570 2570 2571 - if (!test_bit(FLAG_REQUESTED, &desc->flags)) 2571 + if (!test_bit(GPIOD_FLAG_REQUESTED, &desc->flags)) 2572 2572 return NULL; 2573 2573 2574 2574 guard(srcu)(&desc->gdev->desc_srcu); ··· 2736 2736 2737 2737 flags = READ_ONCE(desc->flags); 2738 2738 2739 - if (test_bit(FLAG_BIAS_DISABLE, &flags)) 2739 + if (test_bit(GPIOD_FLAG_BIAS_DISABLE, &flags)) 2740 2740 bias = PIN_CONFIG_BIAS_DISABLE; 2741 - else if (test_bit(FLAG_PULL_UP, &flags)) 2741 + else if (test_bit(GPIOD_FLAG_PULL_UP, &flags)) 2742 2742 bias = PIN_CONFIG_BIAS_PULL_UP; 2743 - else if (test_bit(FLAG_PULL_DOWN, &flags)) 2743 + else if (test_bit(GPIOD_FLAG_PULL_DOWN, &flags)) 2744 2744 bias = PIN_CONFIG_BIAS_PULL_DOWN; 2745 2745 else 2746 2746 return 0; ··· 2882 2882 } 2883 2883 } 2884 2884 if (ret == 0) { 2885 - clear_bit(FLAG_IS_OUT, &desc->flags); 2885 + clear_bit(GPIOD_FLAG_IS_OUT, &desc->flags); 2886 2886 ret = gpio_set_bias(desc); 2887 2887 } 2888 2888 ··· 2955 2955 } 2956 2956 2957 2957 if (!ret) 2958 - set_bit(FLAG_IS_OUT, &desc->flags); 2958 + set_bit(GPIOD_FLAG_IS_OUT, &desc->flags); 2959 2959 trace_gpio_value(desc_to_gpio(desc), 0, val); 2960 2960 trace_gpio_direction(desc_to_gpio(desc), 0, ret); 2961 2961 return ret; ··· 3021 3021 3022 3022 flags = READ_ONCE(desc->flags); 3023 3023 3024 - if (test_bit(FLAG_ACTIVE_LOW, &flags)) 3024 + if (test_bit(GPIOD_FLAG_ACTIVE_LOW, &flags)) 3025 3025 value = !value; 3026 3026 else 3027 3027 value = !!value; 3028 3028 3029 3029 /* GPIOs used for enabled IRQs shall not be set as output */ 3030 - if (test_bit(FLAG_USED_AS_IRQ, &flags) && 3031 - test_bit(FLAG_IRQ_IS_ENABLED, &flags)) { 3030 + if (test_bit(GPIOD_FLAG_USED_AS_IRQ, &flags) && 3031 + test_bit(GPIOD_FLAG_IRQ_IS_ENABLED, &flags)) { 3032 3032 gpiod_err(desc, 3033 3033 "%s: tried to set a GPIO tied to an IRQ as output\n", 3034 3034 __func__); 3035 3035 return -EIO; 3036 3036 } 3037 3037 3038 - if (test_bit(FLAG_OPEN_DRAIN, &flags)) { 3038 + if (test_bit(GPIOD_FLAG_OPEN_DRAIN, &flags)) { 3039 3039 /* First see if we can enable open drain in hardware */ 3040 3040 ret = gpio_set_config(desc, PIN_CONFIG_DRIVE_OPEN_DRAIN); 3041 3041 if (!ret) ··· 3043 3043 /* Emulate open drain by not actively driving the line high */ 3044 3044 if (value) 3045 3045 goto set_output_flag; 3046 - } else if (test_bit(FLAG_OPEN_SOURCE, &flags)) { 3046 + } else if (test_bit(GPIOD_FLAG_OPEN_SOURCE, &flags)) { 3047 3047 ret = gpio_set_config(desc, PIN_CONFIG_DRIVE_OPEN_SOURCE); 3048 3048 if (!ret) 3049 3049 goto set_output_value; ··· 3070 3070 * set the IS_OUT flag or otherwise we won't be able to set the line 3071 3071 * value anymore. 3072 3072 */ 3073 - set_bit(FLAG_IS_OUT, &desc->flags); 3073 + set_bit(GPIOD_FLAG_IS_OUT, &desc->flags); 3074 3074 return 0; 3075 3075 } 3076 3076 ··· 3210 3210 { 3211 3211 VALIDATE_DESC(desc); 3212 3212 /* 3213 - * Handle FLAG_TRANSITORY first, enabling queries to gpiolib for 3213 + * Handle GPIOD_FLAG_TRANSITORY first, enabling queries to gpiolib for 3214 3214 * persistence state. 3215 3215 */ 3216 - assign_bit(FLAG_TRANSITORY, &desc->flags, transitory); 3216 + assign_bit(GPIOD_FLAG_TRANSITORY, &desc->flags, transitory); 3217 3217 3218 3218 /* If the driver supports it, set the persistence state now */ 3219 3219 return gpio_set_config_with_argument_optional(desc, ··· 3231 3231 int gpiod_is_active_low(const struct gpio_desc *desc) 3232 3232 { 3233 3233 VALIDATE_DESC(desc); 3234 - return test_bit(FLAG_ACTIVE_LOW, &desc->flags); 3234 + return test_bit(GPIOD_FLAG_ACTIVE_LOW, &desc->flags); 3235 3235 } 3236 3236 EXPORT_SYMBOL_GPL(gpiod_is_active_low); 3237 3237 ··· 3242 3242 void gpiod_toggle_active_low(struct gpio_desc *desc) 3243 3243 { 3244 3244 VALIDATE_DESC_VOID(desc); 3245 - change_bit(FLAG_ACTIVE_LOW, &desc->flags); 3245 + change_bit(GPIOD_FLAG_ACTIVE_LOW, &desc->flags); 3246 3246 gpiod_line_state_notify(desc, GPIO_V2_LINE_CHANGED_CONFIG); 3247 3247 } 3248 3248 EXPORT_SYMBOL_GPL(gpiod_toggle_active_low); ··· 3448 3448 int hwgpio = gpio_chip_hwgpio(desc); 3449 3449 int value = test_bit(hwgpio, bits); 3450 3450 3451 - if (!raw && test_bit(FLAG_ACTIVE_LOW, &desc->flags)) 3451 + if (!raw && test_bit(GPIOD_FLAG_ACTIVE_LOW, &desc->flags)) 3452 3452 value = !value; 3453 3453 __assign_bit(j, value_bitmap, value); 3454 3454 trace_gpio_value(desc_to_gpio(desc), 1, value); ··· 3510 3510 if (value < 0) 3511 3511 return value; 3512 3512 3513 - if (test_bit(FLAG_ACTIVE_LOW, &desc->flags)) 3513 + if (test_bit(GPIOD_FLAG_ACTIVE_LOW, &desc->flags)) 3514 3514 value = !value; 3515 3515 3516 3516 return value; ··· 3593 3593 } else { 3594 3594 ret = gpiochip_direction_output(guard.gc, offset, 0); 3595 3595 if (!ret) 3596 - set_bit(FLAG_IS_OUT, &desc->flags); 3596 + set_bit(GPIOD_FLAG_IS_OUT, &desc->flags); 3597 3597 } 3598 3598 trace_gpio_direction(desc_to_gpio(desc), value, ret); 3599 3599 if (ret < 0) ··· 3620 3620 if (value) { 3621 3621 ret = gpiochip_direction_output(guard.gc, offset, 1); 3622 3622 if (!ret) 3623 - set_bit(FLAG_IS_OUT, &desc->flags); 3623 + set_bit(GPIOD_FLAG_IS_OUT, &desc->flags); 3624 3624 } else { 3625 3625 ret = gpiochip_direction_input(guard.gc, offset); 3626 3626 } ··· 3635 3635 3636 3636 static int gpiod_set_raw_value_commit(struct gpio_desc *desc, bool value) 3637 3637 { 3638 - if (unlikely(!test_bit(FLAG_IS_OUT, &desc->flags))) 3638 + if (unlikely(!test_bit(GPIOD_FLAG_IS_OUT, &desc->flags))) 3639 3639 return -EPERM; 3640 3640 3641 3641 CLASS(gpio_chip_guard, guard)(desc); ··· 3705 3705 WARN_ON(array_info->gdev->can_sleep); 3706 3706 3707 3707 for (i = 0; i < array_size; i++) { 3708 - if (unlikely(!test_bit(FLAG_IS_OUT, 3708 + if (unlikely(!test_bit(GPIOD_FLAG_IS_OUT, 3709 3709 &desc_array[i]->flags))) 3710 3710 return -EPERM; 3711 3711 } ··· 3769 3769 int hwgpio = gpio_chip_hwgpio(desc); 3770 3770 int value = test_bit(i, value_bitmap); 3771 3771 3772 - if (unlikely(!test_bit(FLAG_IS_OUT, &desc->flags))) 3772 + if (unlikely(!test_bit(GPIOD_FLAG_IS_OUT, &desc->flags))) 3773 3773 return -EPERM; 3774 3774 3775 3775 /* ··· 3779 3779 */ 3780 3780 if (!raw && !(array_info && 3781 3781 test_bit(i, array_info->invert_mask)) && 3782 - test_bit(FLAG_ACTIVE_LOW, &desc->flags)) 3782 + test_bit(GPIOD_FLAG_ACTIVE_LOW, &desc->flags)) 3783 3783 value = !value; 3784 3784 trace_gpio_value(desc_to_gpio(desc), 0, value); 3785 3785 /* 3786 3786 * collect all normal outputs belonging to the same chip 3787 3787 * open drain and open source outputs are set individually 3788 3788 */ 3789 - if (test_bit(FLAG_OPEN_DRAIN, &desc->flags) && !raw) { 3789 + if (test_bit(GPIOD_FLAG_OPEN_DRAIN, &desc->flags) && !raw) { 3790 3790 gpio_set_open_drain_value_commit(desc, value); 3791 - } else if (test_bit(FLAG_OPEN_SOURCE, &desc->flags) && !raw) { 3791 + } else if (test_bit(GPIOD_FLAG_OPEN_SOURCE, &desc->flags) && !raw) { 3792 3792 gpio_set_open_source_value_commit(desc, value); 3793 3793 } else { 3794 3794 __set_bit(hwgpio, mask); ··· 3854 3854 */ 3855 3855 static int gpiod_set_value_nocheck(struct gpio_desc *desc, int value) 3856 3856 { 3857 - if (test_bit(FLAG_ACTIVE_LOW, &desc->flags)) 3857 + if (test_bit(GPIOD_FLAG_ACTIVE_LOW, &desc->flags)) 3858 3858 value = !value; 3859 3859 3860 - if (test_bit(FLAG_OPEN_DRAIN, &desc->flags)) 3860 + if (test_bit(GPIOD_FLAG_OPEN_DRAIN, &desc->flags)) 3861 3861 return gpio_set_open_drain_value_commit(desc, value); 3862 - else if (test_bit(FLAG_OPEN_SOURCE, &desc->flags)) 3862 + else if (test_bit(GPIOD_FLAG_OPEN_SOURCE, &desc->flags)) 3863 3863 return gpio_set_open_source_value_commit(desc, value); 3864 3864 3865 3865 return gpiod_set_raw_value_commit(desc, value); ··· 4063 4063 } 4064 4064 4065 4065 /* To be valid for IRQ the line needs to be input or open drain */ 4066 - if (test_bit(FLAG_IS_OUT, &desc->flags) && 4067 - !test_bit(FLAG_OPEN_DRAIN, &desc->flags)) { 4066 + if (test_bit(GPIOD_FLAG_IS_OUT, &desc->flags) && 4067 + !test_bit(GPIOD_FLAG_OPEN_DRAIN, &desc->flags)) { 4068 4068 chip_err(gc, 4069 4069 "%s: tried to flag a GPIO set as output for IRQ\n", 4070 4070 __func__); 4071 4071 return -EIO; 4072 4072 } 4073 4073 4074 - set_bit(FLAG_USED_AS_IRQ, &desc->flags); 4075 - set_bit(FLAG_IRQ_IS_ENABLED, &desc->flags); 4074 + set_bit(GPIOD_FLAG_USED_AS_IRQ, &desc->flags); 4075 + set_bit(GPIOD_FLAG_IRQ_IS_ENABLED, &desc->flags); 4076 4076 4077 4077 return 0; 4078 4078 } ··· 4094 4094 if (IS_ERR(desc)) 4095 4095 return; 4096 4096 4097 - clear_bit(FLAG_USED_AS_IRQ, &desc->flags); 4098 - clear_bit(FLAG_IRQ_IS_ENABLED, &desc->flags); 4097 + clear_bit(GPIOD_FLAG_USED_AS_IRQ, &desc->flags); 4098 + clear_bit(GPIOD_FLAG_IRQ_IS_ENABLED, &desc->flags); 4099 4099 } 4100 4100 EXPORT_SYMBOL_GPL(gpiochip_unlock_as_irq); 4101 4101 ··· 4104 4104 struct gpio_desc *desc = gpiochip_get_desc(gc, offset); 4105 4105 4106 4106 if (!IS_ERR(desc) && 4107 - !WARN_ON(!test_bit(FLAG_USED_AS_IRQ, &desc->flags))) 4108 - clear_bit(FLAG_IRQ_IS_ENABLED, &desc->flags); 4107 + !WARN_ON(!test_bit(GPIOD_FLAG_USED_AS_IRQ, &desc->flags))) 4108 + clear_bit(GPIOD_FLAG_IRQ_IS_ENABLED, &desc->flags); 4109 4109 } 4110 4110 EXPORT_SYMBOL_GPL(gpiochip_disable_irq); 4111 4111 ··· 4114 4114 struct gpio_desc *desc = gpiochip_get_desc(gc, offset); 4115 4115 4116 4116 if (!IS_ERR(desc) && 4117 - !WARN_ON(!test_bit(FLAG_USED_AS_IRQ, &desc->flags))) { 4117 + !WARN_ON(!test_bit(GPIOD_FLAG_USED_AS_IRQ, &desc->flags))) { 4118 4118 /* 4119 4119 * We must not be output when using IRQ UNLESS we are 4120 4120 * open drain. 4121 4121 */ 4122 - WARN_ON(test_bit(FLAG_IS_OUT, &desc->flags) && 4123 - !test_bit(FLAG_OPEN_DRAIN, &desc->flags)); 4124 - set_bit(FLAG_IRQ_IS_ENABLED, &desc->flags); 4122 + WARN_ON(test_bit(GPIOD_FLAG_IS_OUT, &desc->flags) && 4123 + !test_bit(GPIOD_FLAG_OPEN_DRAIN, &desc->flags)); 4124 + set_bit(GPIOD_FLAG_IRQ_IS_ENABLED, &desc->flags); 4125 4125 } 4126 4126 } 4127 4127 EXPORT_SYMBOL_GPL(gpiochip_enable_irq); ··· 4131 4131 if (offset >= gc->ngpio) 4132 4132 return false; 4133 4133 4134 - return test_bit(FLAG_USED_AS_IRQ, &gc->gpiodev->descs[offset].flags); 4134 + return test_bit(GPIOD_FLAG_USED_AS_IRQ, &gc->gpiodev->descs[offset].flags); 4135 4135 } 4136 4136 EXPORT_SYMBOL_GPL(gpiochip_line_is_irq); 4137 4137 ··· 4164 4164 if (offset >= gc->ngpio) 4165 4165 return false; 4166 4166 4167 - return test_bit(FLAG_OPEN_DRAIN, &gc->gpiodev->descs[offset].flags); 4167 + return test_bit(GPIOD_FLAG_OPEN_DRAIN, &gc->gpiodev->descs[offset].flags); 4168 4168 } 4169 4169 EXPORT_SYMBOL_GPL(gpiochip_line_is_open_drain); 4170 4170 ··· 4173 4173 if (offset >= gc->ngpio) 4174 4174 return false; 4175 4175 4176 - return test_bit(FLAG_OPEN_SOURCE, &gc->gpiodev->descs[offset].flags); 4176 + return test_bit(GPIOD_FLAG_OPEN_SOURCE, &gc->gpiodev->descs[offset].flags); 4177 4177 } 4178 4178 EXPORT_SYMBOL_GPL(gpiochip_line_is_open_source); 4179 4179 ··· 4182 4182 if (offset >= gc->ngpio) 4183 4183 return false; 4184 4184 4185 - return !test_bit(FLAG_TRANSITORY, &gc->gpiodev->descs[offset].flags); 4185 + return !test_bit(GPIOD_FLAG_TRANSITORY, &gc->gpiodev->descs[offset].flags); 4186 4186 } 4187 4187 EXPORT_SYMBOL_GPL(gpiochip_line_is_persistent); 4188 4188 ··· 4224 4224 if (value < 0) 4225 4225 return value; 4226 4226 4227 - if (test_bit(FLAG_ACTIVE_LOW, &desc->flags)) 4227 + if (test_bit(GPIOD_FLAG_ACTIVE_LOW, &desc->flags)) 4228 4228 value = !value; 4229 4229 4230 4230 return value; ··· 4806 4806 int ret; 4807 4807 4808 4808 if (lflags & GPIO_ACTIVE_LOW) 4809 - set_bit(FLAG_ACTIVE_LOW, &desc->flags); 4809 + set_bit(GPIOD_FLAG_ACTIVE_LOW, &desc->flags); 4810 4810 4811 4811 if (lflags & GPIO_OPEN_DRAIN) 4812 - set_bit(FLAG_OPEN_DRAIN, &desc->flags); 4812 + set_bit(GPIOD_FLAG_OPEN_DRAIN, &desc->flags); 4813 4813 else if (dflags & GPIOD_FLAGS_BIT_OPEN_DRAIN) { 4814 4814 /* 4815 4815 * This enforces open drain mode from the consumer side. ··· 4817 4817 * should *REALLY* have specified them as open drain in the 4818 4818 * first place, so print a little warning here. 4819 4819 */ 4820 - set_bit(FLAG_OPEN_DRAIN, &desc->flags); 4820 + set_bit(GPIOD_FLAG_OPEN_DRAIN, &desc->flags); 4821 4821 gpiod_warn(desc, 4822 4822 "enforced open drain please flag it properly in DT/ACPI DSDT/board file\n"); 4823 4823 } 4824 4824 4825 4825 if (lflags & GPIO_OPEN_SOURCE) 4826 - set_bit(FLAG_OPEN_SOURCE, &desc->flags); 4826 + set_bit(GPIOD_FLAG_OPEN_SOURCE, &desc->flags); 4827 4827 4828 4828 if (((lflags & GPIO_PULL_UP) && (lflags & GPIO_PULL_DOWN)) || 4829 4829 ((lflags & GPIO_PULL_UP) && (lflags & GPIO_PULL_DISABLE)) || ··· 4834 4834 } 4835 4835 4836 4836 if (lflags & GPIO_PULL_UP) 4837 - set_bit(FLAG_PULL_UP, &desc->flags); 4837 + set_bit(GPIOD_FLAG_PULL_UP, &desc->flags); 4838 4838 else if (lflags & GPIO_PULL_DOWN) 4839 - set_bit(FLAG_PULL_DOWN, &desc->flags); 4839 + set_bit(GPIOD_FLAG_PULL_DOWN, &desc->flags); 4840 4840 else if (lflags & GPIO_PULL_DISABLE) 4841 - set_bit(FLAG_BIAS_DISABLE, &desc->flags); 4841 + set_bit(GPIOD_FLAG_BIAS_DISABLE, &desc->flags); 4842 4842 4843 4843 ret = gpiod_set_transitory(desc, (lflags & GPIO_TRANSITORY)); 4844 4844 if (ret < 0) ··· 4943 4943 if (!guard.gc) 4944 4944 return -ENODEV; 4945 4945 4946 - if (test_and_set_bit(FLAG_IS_HOGGED, &desc->flags)) 4946 + if (test_and_set_bit(GPIOD_FLAG_IS_HOGGED, &desc->flags)) 4947 4947 return 0; 4948 4948 4949 4949 hwnum = gpio_chip_hwgpio(desc); ··· 4951 4951 local_desc = gpiochip_request_own_desc(guard.gc, hwnum, name, 4952 4952 lflags, dflags); 4953 4953 if (IS_ERR(local_desc)) { 4954 - clear_bit(FLAG_IS_HOGGED, &desc->flags); 4954 + clear_bit(GPIOD_FLAG_IS_HOGGED, &desc->flags); 4955 4955 ret = PTR_ERR(local_desc); 4956 4956 pr_err("requesting hog GPIO %s (chip %s, offset %d) failed, %d\n", 4957 4957 name, gdev->label, hwnum, ret); ··· 4974 4974 { 4975 4975 struct gpio_desc *desc; 4976 4976 4977 - for_each_gpio_desc_with_flag(gc, desc, FLAG_IS_HOGGED) 4977 + for_each_gpio_desc_with_flag(gc, desc, GPIOD_FLAG_IS_HOGGED) 4978 4978 gpiochip_free_own_desc(desc); 4979 4979 } 4980 4980 ··· 5089 5089 } else { 5090 5090 dflags = READ_ONCE(desc->flags); 5091 5091 /* Exclude open drain or open source from fast output */ 5092 - if (test_bit(FLAG_OPEN_DRAIN, &dflags) || 5093 - test_bit(FLAG_OPEN_SOURCE, &dflags)) 5092 + if (test_bit(GPIOD_FLAG_OPEN_DRAIN, &dflags) || 5093 + test_bit(GPIOD_FLAG_OPEN_SOURCE, &dflags)) 5094 5094 __clear_bit(descs->ndescs, 5095 5095 array_info->set_mask); 5096 5096 /* Identify 'fast' pins which require invertion */ ··· 5248 5248 for_each_gpio_desc(gc, desc) { 5249 5249 guard(srcu)(&desc->gdev->desc_srcu); 5250 5250 flags = READ_ONCE(desc->flags); 5251 - is_irq = test_bit(FLAG_USED_AS_IRQ, &flags); 5252 - if (is_irq || test_bit(FLAG_REQUESTED, &flags)) { 5251 + is_irq = test_bit(GPIOD_FLAG_USED_AS_IRQ, &flags); 5252 + if (is_irq || test_bit(GPIOD_FLAG_REQUESTED, &flags)) { 5253 5253 gpiod_get_direction(desc); 5254 - is_out = test_bit(FLAG_IS_OUT, &flags); 5254 + is_out = test_bit(GPIOD_FLAG_IS_OUT, &flags); 5255 5255 value = gpio_chip_get_value(gc, desc); 5256 - active_low = test_bit(FLAG_ACTIVE_LOW, &flags); 5256 + active_low = test_bit(GPIOD_FLAG_ACTIVE_LOW, &flags); 5257 5257 seq_printf(s, " gpio-%-3u (%-20.20s|%-20.20s) %s %s %s%s\n", 5258 5258 gpio, desc->name ?: "", gpiod_get_label(desc), 5259 5259 is_out ? "out" : "in ",
+18 -18
drivers/gpio/gpiolib.h
··· 186 186 struct gpio_device *gdev; 187 187 unsigned long flags; 188 188 /* flag symbols are bit numbers */ 189 - #define FLAG_REQUESTED 0 190 - #define FLAG_IS_OUT 1 191 - #define FLAG_EXPORT 2 /* protected by sysfs_lock */ 192 - #define FLAG_SYSFS 3 /* exported via /sys/class/gpio/control */ 193 - #define FLAG_ACTIVE_LOW 6 /* value has active low */ 194 - #define FLAG_OPEN_DRAIN 7 /* Gpio is open drain type */ 195 - #define FLAG_OPEN_SOURCE 8 /* Gpio is open source type */ 196 - #define FLAG_USED_AS_IRQ 9 /* GPIO is connected to an IRQ */ 197 - #define FLAG_IRQ_IS_ENABLED 10 /* GPIO is connected to an enabled IRQ */ 198 - #define FLAG_IS_HOGGED 11 /* GPIO is hogged */ 199 - #define FLAG_TRANSITORY 12 /* GPIO may lose value in sleep or reset */ 200 - #define FLAG_PULL_UP 13 /* GPIO has pull up enabled */ 201 - #define FLAG_PULL_DOWN 14 /* GPIO has pull down enabled */ 202 - #define FLAG_BIAS_DISABLE 15 /* GPIO has pull disabled */ 203 - #define FLAG_EDGE_RISING 16 /* GPIO CDEV detects rising edge events */ 204 - #define FLAG_EDGE_FALLING 17 /* GPIO CDEV detects falling edge events */ 205 - #define FLAG_EVENT_CLOCK_REALTIME 18 /* GPIO CDEV reports REALTIME timestamps in events */ 206 - #define FLAG_EVENT_CLOCK_HTE 19 /* GPIO CDEV reports hardware timestamps in events */ 189 + #define GPIOD_FLAG_REQUESTED 0 /* GPIO is in use */ 190 + #define GPIOD_FLAG_IS_OUT 1 /* GPIO is in output mode */ 191 + #define GPIOD_FLAG_EXPORT 2 /* GPIO is exported to user-space */ 192 + #define GPIOD_FLAG_SYSFS 3 /* GPIO is exported via /sys/class/gpio */ 193 + #define GPIOD_FLAG_ACTIVE_LOW 6 /* GPIO is active-low */ 194 + #define GPIOD_FLAG_OPEN_DRAIN 7 /* GPIO is open drain type */ 195 + #define GPIOD_FLAG_OPEN_SOURCE 8 /* GPIO is open source type */ 196 + #define GPIOD_FLAG_USED_AS_IRQ 9 /* GPIO is connected to an IRQ */ 197 + #define GPIOD_FLAG_IRQ_IS_ENABLED 10 /* GPIO is connected to an enabled IRQ */ 198 + #define GPIOD_FLAG_IS_HOGGED 11 /* GPIO is hogged */ 199 + #define GPIOD_FLAG_TRANSITORY 12 /* GPIO may lose value in sleep or reset */ 200 + #define GPIOD_FLAG_PULL_UP 13 /* GPIO has pull up enabled */ 201 + #define GPIOD_FLAG_PULL_DOWN 14 /* GPIO has pull down enabled */ 202 + #define GPIOD_FLAG_BIAS_DISABLE 15 /* GPIO has pull disabled */ 203 + #define GPIOD_FLAG_EDGE_RISING 16 /* GPIO CDEV detects rising edge events */ 204 + #define GPIOD_FLAG_EDGE_FALLING 17 /* GPIO CDEV detects falling edge events */ 205 + #define GPIOD_FLAG_EVENT_CLOCK_REALTIME 18 /* GPIO CDEV reports REALTIME timestamps in events */ 206 + #define GPIOD_FLAG_EVENT_CLOCK_HTE 19 /* GPIO CDEV reports hardware timestamps in events */ 207 207 208 208 /* Connection label */ 209 209 struct gpio_desc_label __rcu *label;