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

gpiolib: Pass array info to get/set array functions

In order to make use of array info obtained from gpiod_get_array() and
speed up processing of arrays matching single GPIO chip layout, that
information must be passed to get/set array functions. Extend the
functions' API with that additional parameter and update all users.
Pass NULL if a user builds an array itself from single GPIOs.

Cc: Jonathan Corbet <corbet@lwn.net>
Cc: Miguel Ojeda Sandonis <miguel.ojeda.sandonis@gmail.com>
Cc: Geert Uytterhoeven <geert@linux-m68k.org>
Cc: Sebastien Bourdelin <sebastien.bourdelin@savoirfairelinux.com>
Cc: Lukas Wunner <lukas@wunner.de>
Cc: Peter Korsgaard <peter.korsgaard@barco.com>
Cc: Peter Rosin <peda@axentia.se>
Cc: Andrew Lunn <andrew@lunn.ch>
Cc: Florian Fainelli <f.fainelli@gmail.com>
Cc: "David S. Miller" <davem@davemloft.net>
Cc: Rojhalat Ibrahim <imr@rtschenk.de>
Cc: Dominik Brodowski <linux@dominikbrodowski.net>
Cc: Russell King <rmk+kernel@armlinux.org.uk>
Cc: Kishon Vijay Abraham I <kishon@ti.com>
Cc: Tony Lindgren <tony@atomide.com>
Cc: Lars-Peter Clausen <lars@metafoo.de>
Cc: Michael Hennerich <Michael.Hennerich@analog.com>
Cc: Jonathan Cameron <jic23@kernel.org>
Cc: Hartmut Knaack <knaack.h@gmx.de>
Cc: Peter Meerwald-Stadler <pmeerw@pmeerw.net>
Cc: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
Cc: Jiri Slaby <jslaby@suse.com>
Cc: Yegor Yefremov <yegorslists@googlemail.com>
Cc: Uwe Kleine-König <u.kleine-koenig@pengutronix.de>
Signed-off-by: Janusz Krzysztofik <jmkrzyszt@gmail.com>
Acked-by: Ulf Hansson <ulf.hansson@linaro.org>
Signed-off-by: Linus Walleij <linus.walleij@linaro.org>

authored by

Janusz Krzysztofik and committed by
Linus Walleij 77588c14 bf9346f5

+86 -26
+12 -2
Documentation/driver-api/gpio/consumer.rst
··· 325 325 326 326 int gpiod_get_array_value(unsigned int array_size, 327 327 struct gpio_desc **desc_array, 328 + struct gpio_array *array_info, 328 329 unsigned long *value_bitmap); 329 330 int gpiod_get_raw_array_value(unsigned int array_size, 330 331 struct gpio_desc **desc_array, 332 + struct gpio_array *array_info, 331 333 unsigned long *value_bitmap); 332 334 int gpiod_get_array_value_cansleep(unsigned int array_size, 333 335 struct gpio_desc **desc_array, 336 + struct gpio_array *array_info, 334 337 unsigned long *value_bitmap); 335 338 int gpiod_get_raw_array_value_cansleep(unsigned int array_size, 336 339 struct gpio_desc **desc_array, 340 + struct gpio_array *array_info, 337 341 unsigned long *value_bitmap); 338 342 339 343 void gpiod_set_array_value(unsigned int array_size, 340 344 struct gpio_desc **desc_array, 345 + struct gpio_array *array_info, 341 346 unsigned long *value_bitmap) 342 347 void gpiod_set_raw_array_value(unsigned int array_size, 343 348 struct gpio_desc **desc_array, 349 + struct gpio_array *array_info, 344 350 unsigned long *value_bitmap) 345 351 void gpiod_set_array_value_cansleep(unsigned int array_size, 346 352 struct gpio_desc **desc_array, 353 + struct gpio_array *array_info, 347 354 unsigned long *value_bitmap) 348 355 void gpiod_set_raw_array_value_cansleep(unsigned int array_size, 349 356 struct gpio_desc **desc_array, 357 + struct gpio_array *array_info, 350 358 unsigned long *value_bitmap) 351 359 352 360 The array can be an arbitrary set of GPIOs. The functions will try to access ··· 366 358 The functions take three arguments: 367 359 * array_size - the number of array elements 368 360 * desc_array - an array of GPIO descriptors 361 + * array_info - optional information obtained from gpiod_array_get() 369 362 * value_bitmap - a bitmap to store the GPIOs' values (get) or 370 363 a bitmap of values to assign to the GPIOs (set) 371 364 ··· 377 368 378 369 struct gpio_descs *my_gpio_descs = gpiod_get_array(...); 379 370 gpiod_set_array_value(my_gpio_descs->ndescs, my_gpio_descs->desc, 380 - my_gpio_value_bitmap); 371 + my_gpio_descs->info, my_gpio_value_bitmap); 381 372 382 373 It is also possible to access a completely arbitrary array of descriptors. The 383 374 descriptors may be obtained using any combination of gpiod_get() and 384 375 gpiod_get_array(). Afterwards the array of descriptors has to be setup 385 - manually before it can be passed to one of the above functions. 376 + manually before it can be passed to one of the above functions. In that case, 377 + array_info should be set to NULL. 386 378 387 379 Note that for optimal performance GPIOs belonging to the same chip should be 388 380 contiguous within the array of descriptors.
+4 -4
drivers/auxdisplay/hd44780.c
··· 70 70 n = hd->pins[PIN_CTRL_RW] ? 10 : 9; 71 71 72 72 /* Present the data to the port */ 73 - gpiod_set_array_value_cansleep(n, &hd->pins[PIN_DATA0], values); 73 + gpiod_set_array_value_cansleep(n, &hd->pins[PIN_DATA0], NULL, values); 74 74 75 75 hd44780_strobe_gpio(hd); 76 76 } ··· 87 87 n = hd->pins[PIN_CTRL_RW] ? 6 : 5; 88 88 89 89 /* Present the data to the port */ 90 - gpiod_set_array_value_cansleep(n, &hd->pins[PIN_DATA4], values); 90 + gpiod_set_array_value_cansleep(n, &hd->pins[PIN_DATA4], NULL, values); 91 91 92 92 hd44780_strobe_gpio(hd); 93 93 ··· 96 96 values[0] |= val & 0x0f; 97 97 98 98 /* Present the data to the port */ 99 - gpiod_set_array_value_cansleep(n, &hd->pins[PIN_DATA4], values); 99 + gpiod_set_array_value_cansleep(n, &hd->pins[PIN_DATA4], NULL, values); 100 100 101 101 hd44780_strobe_gpio(hd); 102 102 } ··· 152 152 n = hd->pins[PIN_CTRL_RW] ? 6 : 5; 153 153 154 154 /* Present the data to the port */ 155 - gpiod_set_array_value_cansleep(n, &hd->pins[PIN_DATA4], values); 155 + gpiod_set_array_value_cansleep(n, &hd->pins[PIN_DATA4], NULL, values); 156 156 157 157 hd44780_strobe_gpio(hd); 158 158 }
+3 -2
drivers/bus/ts-nbus.c
··· 114 114 115 115 values[0] = 0; 116 116 117 - gpiod_set_array_value_cansleep(8, ts_nbus->data->desc, values); 117 + gpiod_set_array_value_cansleep(8, ts_nbus->data->desc, 118 + ts_nbus->data->info, values); 118 119 gpiod_set_value_cansleep(ts_nbus->csn, 0); 119 120 gpiod_set_value_cansleep(ts_nbus->strobe, 0); 120 121 gpiod_set_value_cansleep(ts_nbus->ale, 0); ··· 160 159 161 160 values[0] = byte; 162 161 163 - gpiod_set_array_value_cansleep(8, gpios->desc, values); 162 + gpiod_set_array_value_cansleep(8, gpios->desc, gpios->info, values); 164 163 } 165 164 166 165 /*
+4 -2
drivers/gpio/gpio-max3191x.c
··· 313 313 314 314 static void gpiod_set_array_single_value_cansleep(unsigned int ndescs, 315 315 struct gpio_desc **desc, 316 + struct gpio_array *info, 316 317 int value) 317 318 { 318 319 unsigned long *values; ··· 327 326 else 328 327 bitmap_zero(values, ndescs); 329 328 330 - gpiod_set_array_value_cansleep(ndescs, desc, values); 329 + gpiod_set_array_value_cansleep(ndescs, desc, info, values); 331 330 kfree(values); 332 331 } 333 332 ··· 400 399 if (max3191x->modesel_pins) 401 400 gpiod_set_array_single_value_cansleep( 402 401 max3191x->modesel_pins->ndescs, 403 - max3191x->modesel_pins->desc, max3191x->mode); 402 + max3191x->modesel_pins->desc, 403 + max3191x->modesel_pins->info, max3191x->mode); 404 404 405 405 max3191x->ignore_uv = device_property_read_bool(dev, 406 406 "maxim,ignore-undervoltage");
+32 -8
drivers/gpio/gpiolib.c
··· 436 436 true, 437 437 lh->numdescs, 438 438 lh->descs, 439 + NULL, 439 440 vals); 440 441 if (ret) 441 442 return ret; ··· 469 468 true, 470 469 lh->numdescs, 471 470 lh->descs, 471 + NULL, 472 472 vals); 473 473 } 474 474 return -EINVAL; ··· 2786 2784 int gpiod_get_array_value_complex(bool raw, bool can_sleep, 2787 2785 unsigned int array_size, 2788 2786 struct gpio_desc **desc_array, 2787 + struct gpio_array *array_info, 2789 2788 unsigned long *value_bitmap) 2790 2789 { 2791 2790 int i = 0; ··· 2900 2897 * gpiod_get_raw_array_value() - read raw values from an array of GPIOs 2901 2898 * @array_size: number of elements in the descriptor array / value bitmap 2902 2899 * @desc_array: array of GPIO descriptors whose values will be read 2900 + * @array_info: information on applicability of fast bitmap processing path 2903 2901 * @value_bitmap: bitmap to store the read values 2904 2902 * 2905 2903 * Read the raw values of the GPIOs, i.e. the values of the physical lines ··· 2912 2908 */ 2913 2909 int gpiod_get_raw_array_value(unsigned int array_size, 2914 2910 struct gpio_desc **desc_array, 2911 + struct gpio_array *array_info, 2915 2912 unsigned long *value_bitmap) 2916 2913 { 2917 2914 if (!desc_array) 2918 2915 return -EINVAL; 2919 2916 return gpiod_get_array_value_complex(true, false, array_size, 2920 - desc_array, value_bitmap); 2917 + desc_array, array_info, 2918 + value_bitmap); 2921 2919 } 2922 2920 EXPORT_SYMBOL_GPL(gpiod_get_raw_array_value); 2923 2921 ··· 2927 2921 * gpiod_get_array_value() - read values from an array of GPIOs 2928 2922 * @array_size: number of elements in the descriptor array / value bitmap 2929 2923 * @desc_array: array of GPIO descriptors whose values will be read 2924 + * @array_info: information on applicability of fast bitmap processing path 2930 2925 * @value_bitmap: bitmap to store the read values 2931 2926 * 2932 2927 * Read the logical values of the GPIOs, i.e. taking their ACTIVE_LOW status ··· 2938 2931 */ 2939 2932 int gpiod_get_array_value(unsigned int array_size, 2940 2933 struct gpio_desc **desc_array, 2934 + struct gpio_array *array_info, 2941 2935 unsigned long *value_bitmap) 2942 2936 { 2943 2937 if (!desc_array) 2944 2938 return -EINVAL; 2945 2939 return gpiod_get_array_value_complex(false, false, array_size, 2946 - desc_array, value_bitmap); 2940 + desc_array, array_info, 2941 + value_bitmap); 2947 2942 } 2948 2943 EXPORT_SYMBOL_GPL(gpiod_get_array_value); 2949 2944 ··· 3038 3029 int gpiod_set_array_value_complex(bool raw, bool can_sleep, 3039 3030 unsigned int array_size, 3040 3031 struct gpio_desc **desc_array, 3032 + struct gpio_array *array_info, 3041 3033 unsigned long *value_bitmap) 3042 3034 { 3043 3035 int i = 0; ··· 3166 3156 * gpiod_set_raw_array_value() - assign values to an array of GPIOs 3167 3157 * @array_size: number of elements in the descriptor array / value bitmap 3168 3158 * @desc_array: array of GPIO descriptors whose values will be assigned 3159 + * @array_info: information on applicability of fast bitmap processing path 3169 3160 * @value_bitmap: bitmap of values to assign 3170 3161 * 3171 3162 * Set the raw values of the GPIOs, i.e. the values of the physical lines ··· 3177 3166 */ 3178 3167 int gpiod_set_raw_array_value(unsigned int array_size, 3179 3168 struct gpio_desc **desc_array, 3169 + struct gpio_array *array_info, 3180 3170 unsigned long *value_bitmap) 3181 3171 { 3182 3172 if (!desc_array) 3183 3173 return -EINVAL; 3184 3174 return gpiod_set_array_value_complex(true, false, array_size, 3185 - desc_array, value_bitmap); 3175 + desc_array, array_info, value_bitmap); 3186 3176 } 3187 3177 EXPORT_SYMBOL_GPL(gpiod_set_raw_array_value); 3188 3178 ··· 3191 3179 * gpiod_set_array_value() - assign values to an array of GPIOs 3192 3180 * @array_size: number of elements in the descriptor array / value bitmap 3193 3181 * @desc_array: array of GPIO descriptors whose values will be assigned 3182 + * @array_info: information on applicability of fast bitmap processing path 3194 3183 * @value_bitmap: bitmap of values to assign 3195 3184 * 3196 3185 * Set the logical values of the GPIOs, i.e. taking their ACTIVE_LOW status ··· 3202 3189 */ 3203 3190 void gpiod_set_array_value(unsigned int array_size, 3204 3191 struct gpio_desc **desc_array, 3192 + struct gpio_array *array_info, 3205 3193 unsigned long *value_bitmap) 3206 3194 { 3207 3195 if (!desc_array) 3208 3196 return; 3209 3197 gpiod_set_array_value_complex(false, false, array_size, desc_array, 3210 - value_bitmap); 3198 + array_info, value_bitmap); 3211 3199 } 3212 3200 EXPORT_SYMBOL_GPL(gpiod_set_array_value); 3213 3201 ··· 3430 3416 * gpiod_get_raw_array_value_cansleep() - read raw values from an array of GPIOs 3431 3417 * @array_size: number of elements in the descriptor array / value bitmap 3432 3418 * @desc_array: array of GPIO descriptors whose values will be read 3419 + * @array_info: information on applicability of fast bitmap processing path 3433 3420 * @value_bitmap: bitmap to store the read values 3434 3421 * 3435 3422 * Read the raw values of the GPIOs, i.e. the values of the physical lines ··· 3441 3426 */ 3442 3427 int gpiod_get_raw_array_value_cansleep(unsigned int array_size, 3443 3428 struct gpio_desc **desc_array, 3429 + struct gpio_array *array_info, 3444 3430 unsigned long *value_bitmap) 3445 3431 { 3446 3432 might_sleep_if(extra_checks); 3447 3433 if (!desc_array) 3448 3434 return -EINVAL; 3449 3435 return gpiod_get_array_value_complex(true, true, array_size, 3450 - desc_array, value_bitmap); 3436 + desc_array, array_info, 3437 + value_bitmap); 3451 3438 } 3452 3439 EXPORT_SYMBOL_GPL(gpiod_get_raw_array_value_cansleep); 3453 3440 ··· 3457 3440 * gpiod_get_array_value_cansleep() - read values from an array of GPIOs 3458 3441 * @array_size: number of elements in the descriptor array / value bitmap 3459 3442 * @desc_array: array of GPIO descriptors whose values will be read 3443 + * @array_info: information on applicability of fast bitmap processing path 3460 3444 * @value_bitmap: bitmap to store the read values 3461 3445 * 3462 3446 * Read the logical values of the GPIOs, i.e. taking their ACTIVE_LOW status ··· 3467 3449 */ 3468 3450 int gpiod_get_array_value_cansleep(unsigned int array_size, 3469 3451 struct gpio_desc **desc_array, 3452 + struct gpio_array *array_info, 3470 3453 unsigned long *value_bitmap) 3471 3454 { 3472 3455 might_sleep_if(extra_checks); 3473 3456 if (!desc_array) 3474 3457 return -EINVAL; 3475 3458 return gpiod_get_array_value_complex(false, true, array_size, 3476 - desc_array, value_bitmap); 3459 + desc_array, array_info, 3460 + value_bitmap); 3477 3461 } 3478 3462 EXPORT_SYMBOL_GPL(gpiod_get_array_value_cansleep); 3479 3463 ··· 3519 3499 * gpiod_set_raw_array_value_cansleep() - assign values to an array of GPIOs 3520 3500 * @array_size: number of elements in the descriptor array / value bitmap 3521 3501 * @desc_array: array of GPIO descriptors whose values will be assigned 3502 + * @array_info: information on applicability of fast bitmap processing path 3522 3503 * @value_bitmap: bitmap of values to assign 3523 3504 * 3524 3505 * Set the raw values of the GPIOs, i.e. the values of the physical lines ··· 3529 3508 */ 3530 3509 int gpiod_set_raw_array_value_cansleep(unsigned int array_size, 3531 3510 struct gpio_desc **desc_array, 3511 + struct gpio_array *array_info, 3532 3512 unsigned long *value_bitmap) 3533 3513 { 3534 3514 might_sleep_if(extra_checks); 3535 3515 if (!desc_array) 3536 3516 return -EINVAL; 3537 3517 return gpiod_set_array_value_complex(true, true, array_size, desc_array, 3538 - value_bitmap); 3518 + array_info, value_bitmap); 3539 3519 } 3540 3520 EXPORT_SYMBOL_GPL(gpiod_set_raw_array_value_cansleep); 3541 3521 ··· 3561 3539 * gpiod_set_array_value_cansleep() - assign values to an array of GPIOs 3562 3540 * @array_size: number of elements in the descriptor array / value bitmap 3563 3541 * @desc_array: array of GPIO descriptors whose values will be assigned 3542 + * @array_info: information on applicability of fast bitmap processing path 3564 3543 * @value_bitmap: bitmap of values to assign 3565 3544 * 3566 3545 * Set the logical values of the GPIOs, i.e. taking their ACTIVE_LOW status ··· 3571 3548 */ 3572 3549 void gpiod_set_array_value_cansleep(unsigned int array_size, 3573 3550 struct gpio_desc **desc_array, 3551 + struct gpio_array *array_info, 3574 3552 unsigned long *value_bitmap) 3575 3553 { 3576 3554 might_sleep_if(extra_checks); 3577 3555 if (!desc_array) 3578 3556 return; 3579 3557 gpiod_set_array_value_complex(false, true, array_size, desc_array, 3580 - value_bitmap); 3558 + array_info, value_bitmap); 3581 3559 } 3582 3560 EXPORT_SYMBOL_GPL(gpiod_set_array_value_cansleep); 3583 3561
+2
drivers/gpio/gpiolib.h
··· 196 196 int gpiod_get_array_value_complex(bool raw, bool can_sleep, 197 197 unsigned int array_size, 198 198 struct gpio_desc **desc_array, 199 + struct gpio_array *array_info, 199 200 unsigned long *value_bitmap); 200 201 int gpiod_set_array_value_complex(bool raw, bool can_sleep, 201 202 unsigned int array_size, 202 203 struct gpio_desc **desc_array, 204 + struct gpio_array *array_info, 203 205 unsigned long *value_bitmap); 204 206 205 207 /* This is just passed between gpiolib and devres */
+2 -1
drivers/i2c/muxes/i2c-mux-gpio.c
··· 30 30 31 31 values[0] = val; 32 32 33 - gpiod_set_array_value_cansleep(mux->data.n_gpios, mux->gpios, values); 33 + gpiod_set_array_value_cansleep(mux->data.n_gpios, mux->gpios, NULL, 34 + values); 34 35 } 35 36 36 37 static int i2c_mux_gpio_select(struct i2c_mux_core *muxc, u32 chan)
+1 -1
drivers/mmc/core/pwrseq_simple.c
··· 46 46 values[0] = value; 47 47 48 48 gpiod_set_array_value_cansleep(nvalues, reset_gpios->desc, 49 - values); 49 + reset_gpios->info, values); 50 50 } 51 51 } 52 52
+2 -1
drivers/mux/gpio.c
··· 27 27 values[0] = state; 28 28 29 29 gpiod_set_array_value_cansleep(mux_gpio->gpios->ndescs, 30 - mux_gpio->gpios->desc, values); 30 + mux_gpio->gpios->desc, 31 + mux_gpio->gpios->info, values); 31 32 32 33 return 0; 33 34 }
+1 -1
drivers/net/phy/mdio-mux-gpio.c
··· 34 34 values[0] = desired_child; 35 35 36 36 gpiod_set_array_value_cansleep(s->gpios->ndescs, s->gpios->desc, 37 - values); 37 + s->gpios->info, values); 38 38 39 39 return 0; 40 40 }
+1 -1
drivers/pcmcia/soc_common.c
··· 364 364 } 365 365 366 366 if (n) 367 - gpiod_set_array_value_cansleep(n, descs, values); 367 + gpiod_set_array_value_cansleep(n, descs, NULL, values); 368 368 369 369 /* 370 370 * This really needs a better solution. The IRQ
+3 -1
drivers/phy/motorola/phy-mapphone-mdm6600.c
··· 162 162 values[0] = val; 163 163 164 164 gpiod_set_array_value_cansleep(PHY_MDM6600_NR_CMD_LINES, 165 - ddata->cmd_gpios->desc, values); 165 + ddata->cmd_gpios->desc, 166 + ddata->cmd_gpios->info, values); 166 167 } 167 168 168 169 /** ··· 182 181 183 182 error = gpiod_get_array_value_cansleep(PHY_MDM6600_NR_STATUS_LINES, 184 183 ddata->status_gpios->desc, 184 + ddata->status_gpios->info, 185 185 values); 186 186 if (error) 187 187 return;
+2 -1
drivers/staging/iio/adc/ad7606.c
··· 230 230 values[0] = ret; 231 231 232 232 mutex_lock(&st->lock); 233 - gpiod_set_array_value(3, st->gpio_os->desc, values); 233 + gpiod_set_array_value(3, st->gpio_os->desc, st->gpio_os->info, 234 + values); 234 235 st->oversampling = val; 235 236 mutex_unlock(&st->lock); 236 237
+1 -1
drivers/tty/serial/serial_mctrl_gpio.c
··· 53 53 mctrl & mctrl_gpios_desc[i].mctrl); 54 54 count++; 55 55 } 56 - gpiod_set_array_value(count, desc_array, values); 56 + gpiod_set_array_value(count, desc_array, NULL, values); 57 57 } 58 58 EXPORT_SYMBOL_GPL(mctrl_gpio_set); 59 59
+16
include/linux/gpio/consumer.h
··· 114 114 int gpiod_get_value(const struct gpio_desc *desc); 115 115 int gpiod_get_array_value(unsigned int array_size, 116 116 struct gpio_desc **desc_array, 117 + struct gpio_array *array_info, 117 118 unsigned long *value_bitmap); 118 119 void gpiod_set_value(struct gpio_desc *desc, int value); 119 120 void gpiod_set_array_value(unsigned int array_size, 120 121 struct gpio_desc **desc_array, 122 + struct gpio_array *array_info, 121 123 unsigned long *value_bitmap); 122 124 int gpiod_get_raw_value(const struct gpio_desc *desc); 123 125 int gpiod_get_raw_array_value(unsigned int array_size, 124 126 struct gpio_desc **desc_array, 127 + struct gpio_array *array_info, 125 128 unsigned long *value_bitmap); 126 129 void gpiod_set_raw_value(struct gpio_desc *desc, int value); 127 130 int gpiod_set_raw_array_value(unsigned int array_size, 128 131 struct gpio_desc **desc_array, 132 + struct gpio_array *array_info, 129 133 unsigned long *value_bitmap); 130 134 131 135 /* Value get/set from sleeping context */ 132 136 int gpiod_get_value_cansleep(const struct gpio_desc *desc); 133 137 int gpiod_get_array_value_cansleep(unsigned int array_size, 134 138 struct gpio_desc **desc_array, 139 + struct gpio_array *array_info, 135 140 unsigned long *value_bitmap); 136 141 void gpiod_set_value_cansleep(struct gpio_desc *desc, int value); 137 142 void gpiod_set_array_value_cansleep(unsigned int array_size, 138 143 struct gpio_desc **desc_array, 144 + struct gpio_array *array_info, 139 145 unsigned long *value_bitmap); 140 146 int gpiod_get_raw_value_cansleep(const struct gpio_desc *desc); 141 147 int gpiod_get_raw_array_value_cansleep(unsigned int array_size, 142 148 struct gpio_desc **desc_array, 149 + struct gpio_array *array_info, 143 150 unsigned long *value_bitmap); 144 151 void gpiod_set_raw_value_cansleep(struct gpio_desc *desc, int value); 145 152 int gpiod_set_raw_array_value_cansleep(unsigned int array_size, 146 153 struct gpio_desc **desc_array, 154 + struct gpio_array *array_info, 147 155 unsigned long *value_bitmap); 148 156 149 157 int gpiod_set_debounce(struct gpio_desc *desc, unsigned debounce); ··· 349 341 } 350 342 static inline int gpiod_get_array_value(unsigned int array_size, 351 343 struct gpio_desc **desc_array, 344 + struct gpio_array *array_info, 352 345 unsigned long *value_bitmap) 353 346 { 354 347 /* GPIO can never have been requested */ ··· 363 354 } 364 355 static inline void gpiod_set_array_value(unsigned int array_size, 365 356 struct gpio_desc **desc_array, 357 + struct gpio_array *array_info, 366 358 unsigned long *value_bitmap) 367 359 { 368 360 /* GPIO can never have been requested */ ··· 377 367 } 378 368 static inline int gpiod_get_raw_array_value(unsigned int array_size, 379 369 struct gpio_desc **desc_array, 370 + struct gpio_array *array_info, 380 371 unsigned long *value_bitmap) 381 372 { 382 373 /* GPIO can never have been requested */ ··· 391 380 } 392 381 static inline int gpiod_set_raw_array_value(unsigned int array_size, 393 382 struct gpio_desc **desc_array, 383 + struct gpio_array *array_info, 394 384 unsigned long *value_bitmap) 395 385 { 396 386 /* GPIO can never have been requested */ ··· 407 395 } 408 396 static inline int gpiod_get_array_value_cansleep(unsigned int array_size, 409 397 struct gpio_desc **desc_array, 398 + struct gpio_array *array_info, 410 399 unsigned long *value_bitmap) 411 400 { 412 401 /* GPIO can never have been requested */ ··· 421 408 } 422 409 static inline void gpiod_set_array_value_cansleep(unsigned int array_size, 423 410 struct gpio_desc **desc_array, 411 + struct gpio_array *array_info, 424 412 unsigned long *value_bitmap) 425 413 { 426 414 /* GPIO can never have been requested */ ··· 435 421 } 436 422 static inline int gpiod_get_raw_array_value_cansleep(unsigned int array_size, 437 423 struct gpio_desc **desc_array, 424 + struct gpio_array *array_info, 438 425 unsigned long *value_bitmap) 439 426 { 440 427 /* GPIO can never have been requested */ ··· 450 435 } 451 436 static inline int gpiod_set_raw_array_value_cansleep(unsigned int array_size, 452 437 struct gpio_desc **desc_array, 438 + struct gpio_array *array_info, 453 439 unsigned long *value_bitmap) 454 440 { 455 441 /* GPIO can never have been requested */