Skip to contentSkip to conversation

gpiolib: allow simultaneous setting of multiple GPIO outputs

PATCH Superseded Rojhalat Ibrahim 4 participants 6 messages May 27, 2014 – Jun 2, 2014

Subsystems (2)

v3 of 6 Superseded Latest is v6 →

lore
Share & tools
lore
#0 lore raw

PATCH v3 1/2 gpiolib: allow simultaneous setting of multiple GPIO outputs

Introduce a new function gpiod_set_raw_array to the consumer interface which allows setting multiple outputs with just one function call. Also add an optional set_multiple function to the driver interface. Without an implementation of that function in the chip driver outputs are set sequentially.

Implementing the set_multiple function in a chip driver allows for:
- Improved performance for certain use cases. The original motivation for this was the task of configuring an FPGA. In that specific case, where 9 GPIO lines have to be set many times, configuration time goes down from 48 s to 19 s when using the new function.
- Simultaneous glitch-free setting of multiple pins on any kind of parallel bus attached to GPIOs provided they all reside on the same chip and bank.

Limitations:
- Performance is only improved for normal high-low outputs. Open drain and open source outputs are always set separately from each other. Those kinds of outputs could probably be accelerated in a similar way if we could forgo the error checking when setting GPIO directions.
- There is no gpiod_set_array function that regards the ACTIVE_LOW bits. The raw function should be sufficient for many use cases. So I avoided the code duplication the other functions would require.

---
Change log:
v3: - add documentation
- change commit message
v2: - use descriptor interface
- allow arbitrary groups of GPIOs spanning multiple chips

 Documentation/gpio/consumer.txt |  17 ++++++
 drivers/gpio/gpiolib.c          | 116 ++++++++++++++++++++++++++++++++++++++++
 include/linux/gpio/consumer.h   |  18 +++++++
 include/linux/gpio/driver.h     |   3 ++
 4 files changed, 154 insertions(+)
Documentation/gpio/consumer.txt +17 -0
index 09854fe..affcd9b 100644
@@ -163,6 +163,23 @@ The active-low state of a GPIO can also be queried using the following call:
 Note that these functions should only be used with great moderation ; a driver
 should not have to care about the physical line level.
 
+Set multiple GPIO outputs with a single function call
+-----------------------------------------------------
+The following two functions set the raw output values of an array of GPIOs:
+
+	void gpiod_set_raw_array(unsigned int array_size,
+				 struct gpio_desc **desc_array,
+				 int *value_array)
+	void gpiod_set_raw_array_cansleep(unsigned int array_size,
+					  struct gpio_desc **desc_array,
+					  int *value_array)
+
+The array can be an arbitrary set of GPIOs. The functions will try to set
+GPIOs belonging to the same bank or chip simultaneously if supported by the
+corresponding chip driver. In that case a significantly improved performance
+can be expected. If simultaneous setting is not possible the GPIOs will be set
+sequentially.
+
 GPIOs mapped to IRQs
 --------------------
 GPIO lines can quite often be used as IRQs. You can get the IRQ number
drivers/gpio/gpiolib.c +116 -0

134 lines not on this page · raw message

include/linux/gpio/consumer.h +18 -0
index bed128e..1d0bab3 100644
@@ -42,12 +42,17 @@ int gpiod_get_value(const struct gpio_desc *desc);
 void gpiod_set_value(struct gpio_desc *desc, int value);
 int gpiod_get_raw_value(const struct gpio_desc *desc);
 void gpiod_set_raw_value(struct gpio_desc *desc, int value);
+void gpiod_set_raw_array(unsigned int array_size,
+			 struct gpio_desc **desc_array, int *value_array);
 
 /* Value get/set from sleeping context */
 int gpiod_get_value_cansleep(const struct gpio_desc *desc);
 void gpiod_set_value_cansleep(struct gpio_desc *desc, int value);
 int gpiod_get_raw_value_cansleep(const struct gpio_desc *desc);
 void gpiod_set_raw_value_cansleep(struct gpio_desc *desc, int value);
+void gpiod_set_raw_array_cansleep(unsigned int array_size,
+				  struct gpio_desc **desc_array,
+				  int *value_array);
 
 int gpiod_set_debounce(struct gpio_desc *desc, unsigned debounce);
 
@@ -150,6 +155,12 @@ static inline void gpiod_set_raw_value(struct gpio_desc *desc, int value)
 	/* GPIO can never have been requested */
 	WARN_ON(1);
 }
+void gpiod_set_raw_array(unsigned int array_size,
+			 struct gpio_desc **desc_array, int *value_array)
+{
+	/* GPIO can never have been requested */
+	WARN_ON(1);
+}
 
 static inline int gpiod_get_value_cansleep(const struct gpio_desc *desc)
 {
@@ -174,6 +185,13 @@ static inline void gpiod_set_raw_value_cansleep(struct gpio_desc *desc,
 	/* GPIO can never have been requested */
 	WARN_ON(1);
 }
+void gpiod_set_raw_array_cansleep(unsigned int array_size,
+				  struct gpio_desc **desc_array,
+				  int *value_array)
+{
+	/* GPIO can never have been requested */
+	WARN_ON(1);
+}
 
 static inline int gpiod_set_debounce(struct gpio_desc *desc, unsigned debounce)
 {
include/linux/gpio/driver.h +3 -0
index 1827b43..d7968c8 100644
@@ -32,6 +32,7 @@ struct seq_file;
  * @get: returns value for signal "offset"; for output signals this
  *	returns either the value actually sensed, or zero
  * @set: assigns output value for signal "offset"
+ * @set_multiple: assigns output values for multiple signals defined by "mask"
  * @set_debounce: optional hook for setting debounce time for specified gpio in
  *      interrupt triggered gpio chips
  * @to_irq: optional hook supporting non-static gpio_to_irq() mappings;
@@ -84,6 +85,8 @@ struct gpio_chip {
 						unsigned offset);
 	void			(*set)(struct gpio_chip *chip,
 						unsigned offset, int value);
+	void			(*set_multiple)(struct gpio_chip *chip,
+						u32 *mask, u32 *bits);
 	int			(*set_debounce)(struct gpio_chip *chip,
 						unsigned offset,
 						unsigned debounce);

--
1.8.5.5

#1 lore raw
Quoted 23 lines · Rojhalat Ibrahim

Introduce a new function gpiod_set_raw_array to the consumer interface which allows setting multiple outputs with just one function call. Also add an optional set_multiple function to the driver interface. Without an implementation of that function in the chip driver outputs are set sequentially.

Implementing the set_multiple function in a chip driver allows for:
- Improved performance for certain use cases. The original motivation for this was the task of configuring an FPGA. In that specific case, where 9 GPIO lines have to be set many times, configuration time goes down from 48 s to 19 s when using the new function.
- Simultaneous glitch-free setting of multiple pins on any kind of parallel bus attached to GPIOs provided they all reside on the same chip and bank.

Limitations:
- Performance is only improved for normal high-low outputs. Open drain and open source outputs are always set separately from each other. Those kinds of outputs could probably be accelerated in a similar way if we could forgo the error checking when setting GPIO directions.
- There is no gpiod_set_array function that regards the ACTIVE_LOW bits. The raw function should be sufficient for many use cases. So I avoided the code duplication the other functions would require.

Quoted 7 lines

---
Change log:
v3: - add documentation
- change commit message
v2: - use descriptor interface
- allow arbitrary groups of GPIOs spanning multiple chips

This concept has been brought up before. Please keep Grant Likley in the loop on these postings as he has some history with this.

As this is a speed optimization basically, do you have performance numbers? Like how much quicker is your code in some critical usecase as measured by perf or throughput whatever before and after doing this?

Notice that the SPI bitbang driver in drivers/spi/spi-gpio.c was one of the most important consumers of this API IIRC. So I'm CC:ing Mark Brown.

Documentation/gpio/consumer.txt The active-low state of a GPIO can also be queried using the following call: · line 175

Quoted 8 lines
Documentation/gpio/consumer.txt +8 -0
+The following two functions set the raw output values of an array of GPIOs:
+
+       void gpiod_set_raw_array(unsigned int array_size,
+                                struct gpio_desc **desc_array,
+                                int *value_array)
+       void gpiod_set_raw_array_cansleep(unsigned int array_size,
+                                         struct gpio_desc **desc_array,
+                                         int *value_array)

So this interface looks quite nice.

I don't see why the complex loop in the raw setter below cannot actually also handle non-raw (cooked? hehe) values with some single-liner to invert the value if it is active low.

Quoted 1 line

+static void _gpio_chip_set_multiple(struct gpio_chip *chip,

I hate _underscored function names, just call it
gpio_chip_set_multiple_offsets() or whatever.

drivers/gpio/gpiolib.c static void _gpiod_set_raw_value(struct gpio_desc *desc, bool value) · line 2351

Quoted 3 lines
drivers/gpio/gpiolib.c +3 -0
+                                   u32 mask[ARCH_NR_GPIOS/32],
+                                   u32 bits[ARCH_NR_GPIOS/32])
+{

First: NO, you NEVER tie any code into ARCH_NR_GPIOS because that is something we want to get rid of. Just use regular pointers, add a count argument if need be.

drivers/gpio/gpiolib.c static void _gpiod_set_raw_value(struct gpio_desc *desc, bool value) · line 2353

Quoted 2 lines
drivers/gpio/gpiolib.c +2 -0
+       if (chip->set_multiple) {
+               chip->set_multiple(chip, mask, bits);

Simple and quick OK. But even this is making a quite nasty assumption...

drivers/gpio/gpiolib.c static void _gpiod_set_raw_value(struct gpio_desc *desc, bool value) · line 2356

Quoted 3 lines
drivers/gpio/gpiolib.c +3 -0
+       } else {
+               int i;
+               for (i = 0; i < ARCH_NR_GPIOS; i++) {

As I said you cannot depend on ARCH_NR_GPIOS and not introduce more dependencies to it. Figure out something else. Like using chip->ngpio to iterate.

Quoted 4 lines
drivers/gpio/gpiolib.c +4 -0
+                       if (i > chip->ngpio - 1)
+                               break;
+                       if (mask[i/32] == 0) {
+                               /* skip ahead */

drivers/gpio/gpiolib.c static void _gpiod_set_raw_value(struct gpio_desc *desc, bool value) · line 2370

Quoted 10 lines
drivers/gpio/gpiolib.c +10 -0
+                               i = (i/32 + 1) * 32 - 1;
+                               continue;
+                       }
+                       if (mask[i/32] & (1 << (i % 32))) {
+                               chip->set(chip, i, (bits[i/32] >> (i % 32)) & 1);
+                               mask[i/32] &= ~(1 << (i % 32));
+                       }
+               }
+       }
+}

This code is a bit convoluted but I *guess* the idea is to iterate over the 32 bits in the argument word by word. Add some comments describing what's going on.

Some chips have 8bit or 16bit registers actually but AFAICT that is not what this is about, rather about the fact that the function takes 32bit arguments.

Quoted 1 line

+static void _gpiod_set_raw_array(unsigned int array_size,

No underscored function name.

drivers/gpio/gpiolib.c static void _gpiod_set_raw_value(struct gpio_desc *desc, bool value) · line 2378

Quoted 6 lines
drivers/gpio/gpiolib.c +6 -0
+                                struct gpio_desc **desc_array,
+                                int *value_array)
+{
+       struct gpio_chip *chip = desc_array[0]->chip;
+       u32 mask[ARCH_NR_GPIOS/32];
+       u32 bits[ARCH_NR_GPIOS/32];

Again dependency to ARCH_NR_GPIOS. Don't do it.

drivers/gpio/gpiolib.c static void _gpiod_set_raw_value(struct gpio_desc *desc, bool value) · line 2389

Quoted 11 lines
drivers/gpio/gpiolib.c +11 -0
+       int count = 0;
+       int i;
+
+       memset(mask, 0, sizeof(mask));
+       for (i = 0; i < array_size; i++) {
+               struct gpio_desc *desc = desc_array[i];
+               int hwgpio = gpio_chip_hwgpio(desc);
+               int value = value_array[i];
+
+               /* another chip; push collected bits to outputs */
+               if (desc->chip != chip) {

Clever logic!

Quoted 13 lines
drivers/gpio/gpiolib.c +13 -0
+                       if (count != 0) {
+                               _gpio_chip_set_multiple(chip, mask, bits);
+                               memset(mask, 0, sizeof(mask));
+                               count = 0;
+                       }
+                       chip = desc->chip;
+               }
+               /* collect all normal outputs belonging to the same chip */
+               /* open drain and open source outputs are set individually */
+               trace_gpio_value(desc_to_gpio(desc), 0, value);
+               if (test_bit(FLAG_OPEN_DRAIN, &desc->flags)) {
+                       _gpio_set_open_drain_value(desc, value);
+               } else if (test_bit(FLAG_OPEN_SOURCE, &desc->flags)) {

drivers/gpio/gpiolib.c static void _gpiod_set_raw_value(struct gpio_desc *desc, bool value) · line 2412

Quoted 10 lines
drivers/gpio/gpiolib.c +10 -0
+                       _gpio_set_open_source_value(desc, value);
+               } else {
+                       mask[hwgpio/32] |= (1 << (hwgpio % 32));
+                       if (value) {
+                               bits[hwgpio/32] |= (1 << (hwgpio % 32));
+                       } else {
+                               bits[hwgpio/32] &= ~(1 << (hwgpio % 32));
+                       }
+                       count++;
+               }

This is also real smart and nice code.

The assumption is that this iteration hotloop will be quicker to run, and the driver can take shortcuts improving performance. As mentione above we need some proof of that as it complicates the code a lot for this performance improvement.

Quoted 6 lines
drivers/gpio/gpiolib.c +6 -0
+       }
+       if (count != 0) {
+               _gpio_chip_set_multiple(chip, mask, bits);
+       }
+}
+

(...)

Quoted 15 lines

static inline int gpiod_set_debounce(struct gpio_desc *desc, unsigned debounce) {

include/linux/gpio/driver.h +1 -0
index 1827b43..d7968c8 100644
@@ -32,6 +32,7 @@ struct seq_file;
  * @get: returns value for signal "offset"; for output signals this
  *     returns either the value actually sensed, or zero
  * @set: assigns output value for signal "offset"
+ * @set_multiple: assigns output values for multiple signals defined by "mask"
  * @set_debounce: optional hook for setting debounce time for specified gpio in
  *      interrupt triggered gpio chips
  * @to_irq: optional hook supporting non-static gpio_to_irq() mappings;

include/linux/gpio/driver.h struct gpio_chip { · line 89

Quoted 5 lines
include/linux/gpio/driver.h +2 -0
@@ -84,6 +85,8 @@ struct gpio_chip {
                                                unsigned offset);
        void                    (*set)(struct gpio_chip *chip,
                                                unsigned offset, int value);
+       void                    (*set_multiple)(struct gpio_chip *chip,
+                                               u32 *mask, u32 *bits);

This sets the chunk size to 32bits which means that any GPIO controller with say 8bit registers will get a complex demuxing scheme.

But thinking of it I think it's a reasonable compromise given that so many GPIO drivers are actually 32bit.

However some of the real slow I2C expander GPIOs are 8bit.

Yours,
Linus Walleij

#4 lore raw
In reply to Rojhalat Ibrahim
Quoted 14 lines · Rojhalat Ibrahim

Introduce a new function gpiod_set_raw_array to the consumer interface which allows setting multiple outputs with just one function call. Also add an optional set_multiple function to the driver interface. Without an implementation of that function in the chip driver outputs are set sequentially.

Implementing the set_multiple function in a chip driver allows for:
- Improved performance for certain use cases. The original motivation for this was the task of configuring an FPGA. In that specific case, where 9 GPIO lines have to be set many times, configuration time goes down from 48 s to 19 s when using the new function.
- Simultaneous glitch-free setting of multiple pins on any kind of parallel bus attached to GPIOs provided they all reside on the same chip and bank.

Quoted 8 lines

Limitations:
- Performance is only improved for normal high-low outputs. Open drain and open source outputs are always set separately from each other. Those kinds of outputs could probably be accelerated in a similar way if we could forgo the error checking when setting GPIO directions.
- There is no gpiod_set_array function that regards the ACTIVE_LOW bits. The raw function should be sufficient for many use cases. So I avoided the code duplication the other functions would require.

How much effort would it be to also implement this function? IIUC it should just require one extra pass of the values array prior to calling gpiod_set_raw_array().

Quoted 29 lines

---
Change log:
v3: - add documentation
- change commit message
v2: - use descriptor interface
- allow arbitrary groups of GPIOs spanning multiple chips

 Documentation/gpio/consumer.txt |  17 ++++++
 drivers/gpio/gpiolib.c          | 116 ++++++++++++++++++++++++++++++++++++++++
 include/linux/gpio/consumer.h   |  18 +++++++
 include/linux/gpio/driver.h     |   3 ++
 4 files changed, 154 insertions(+)
Documentation/gpio/consumer.txt +6 -0
index 09854fe..affcd9b 100644
@@ -163,6 +163,23 @@ The active-low state of a GPIO can also be queried using the following call:
 Note that these functions should only be used with great moderation ; a driver
 should not have to care about the physical line level.
 
+Set multiple GPIO outputs with a single function call
+-----------------------------------------------------
+The following two functions set the raw output values of an array of GPIOs:
+
+       void gpiod_set_raw_array(unsigned int array_size,
+                                struct gpio_desc **desc_array,

Documentation/gpio/consumer.txt The active-low state of a GPIO can also be queried using the following call: · line 181

Quoted 10 lines
Documentation/gpio/consumer.txt +10 -0
+                                int *value_array)
+       void gpiod_set_raw_array_cansleep(unsigned int array_size,
+                                         struct gpio_desc **desc_array,
+                                         int *value_array)
+
+The array can be an arbitrary set of GPIOs. The functions will try to set
+GPIOs belonging to the same bank or chip simultaneously if supported by the
+corresponding chip driver. In that case a significantly improved performance
+can be expected. If simultaneous setting is not possible the GPIOs will be set
+sequentially.

Nice and clean interface, taking advantage of the descriptor interface.

Quoted 11 lines
Documentation/gpio/consumer.txt +1 -0
+
 GPIOs mapped to IRQs
 --------------------
 GPIO lines can quite often be used as IRQs. You can get the IRQ number
drivers/gpio/gpiolib.c +0 -0
index f48817d..ee67ef1 100644
@@ -2345,6 +2345,77 @@ static void _gpiod_set_raw_value(struct gpio_desc *desc, bool value)
                chip->set(chip, gpio_chip_hwgpio(desc), value);
 }

drivers/gpio/gpiolib.c static void _gpiod_set_raw_value(struct gpio_desc *desc, bool value) · line 2356

Quoted 10 lines
drivers/gpio/gpiolib.c +9 -0
 
+static void _gpio_chip_set_multiple(struct gpio_chip *chip,
+                                   u32 mask[ARCH_NR_GPIOS/32],
+                                   u32 bits[ARCH_NR_GPIOS/32])
+{
+       if (chip->set_multiple) {
+               chip->set_multiple(chip, mask, bits);
+       } else {
+               int i;
+               for (i = 0; i < ARCH_NR_GPIOS; i++) {

As Linus already said, please avoid using the deprecated ARCH_NR_GPIOS. chip->ngpio should be just as usable in your case...

drivers/gpio/gpiolib.c static void _gpiod_set_raw_value(struct gpio_desc *desc, bool value) · line 2358

Quoted 2 lines
drivers/gpio/gpiolib.c +2 -0
+                       if (i > chip->ngpio - 1)
+                               break;

... and it would allow you to remove that test.

drivers/gpio/gpiolib.c static void _gpiod_set_raw_value(struct gpio_desc *desc, bool value) · line 2364

Quoted 6 lines
drivers/gpio/gpiolib.c +6 -0
+                       if (mask[i/32] == 0) {
+                               /* skip ahead */
+                               i = (i/32 + 1) * 32 - 1;
+                               continue;
+                       }
+                       if (mask[i/32] & (1 << (i % 32))) {

BIT(i % 32)? (and everywhere else where it applies)

drivers/gpio/gpiolib.c static void _gpiod_set_raw_value(struct gpio_desc *desc, bool value) · line 2365

Quoted 1 line
drivers/gpio/gpiolib.c +1 -0
+                               chip->set(chip, i, (bits[i/32] >> (i % 32)) & 1);

Why are you putting a space around the operator in "i % 32" but not in "i/32" ?

drivers/gpio/gpiolib.c static void _gpiod_set_raw_value(struct gpio_desc *desc, bool value) · line 2366

Quoted 1 line
drivers/gpio/gpiolib.c +1 -0
+                               mask[i/32] &= ~(1 << (i % 32));

There are lots of mask[i/32] and bits[i/32] here. I'm sure the compiler will optimize them away, but for code clarity it might be worth to have each set of u32 be processed by another (inline) function.

drivers/gpio/gpiolib.c static void _gpiod_set_raw_value(struct gpio_desc *desc, bool value) · line 2378

Quoted 12 lines
drivers/gpio/gpiolib.c +12 -0
+                       }
+               }
+       }
+}
+
+static void _gpiod_set_raw_array(unsigned int array_size,
+                                struct gpio_desc **desc_array,
+                                int *value_array)
+{
+       struct gpio_chip *chip = desc_array[0]->chip;
+       u32 mask[ARCH_NR_GPIOS/32];
+       u32 bits[ARCH_NR_GPIOS/32];

If ARCH_NR_GPIOS is not a multiple of 32, your array will miss one element. You should use DIV_ROUND_UP(ARCH_NR_GPIOS, 32), but even better, let's not use ARCH_NR_GPIOS at all.

Maybe someone will kill me for suggesting this, but I wonder if you could not use C99's VLA-on-stack feature here? Please rap my knuckles if this is taboo in the kernel, but something like this may work (untested though):

i = 0;

while (i < array_size) {
       struct gpio_chip *chip = desc_array[i]->chip;
       u32 mask[DIV_ROUND_UP(chip->ngpios, 32)];
        ....

        do {
             /* Process values for GPIOs of the same chip */
        } while (++i < array_size && desc_array[i]->chip != chip);

        _gpio_chip_set_multiple(...);
    }
}

Something like this. It should also avoid some of the repetitions in your code. That is, *if* the stack VLAs are usable at all and someone does not fall on us shouting how evil this is.

Quoted 17 lines
drivers/gpio/gpiolib.c +17 -0
+       int count = 0;
+       int i;
+
+       memset(mask, 0, sizeof(mask));
+       for (i = 0; i < array_size; i++) {
+               struct gpio_desc *desc = desc_array[i];
+               int hwgpio = gpio_chip_hwgpio(desc);
+               int value = value_array[i];
+
+               /* another chip; push collected bits to outputs */
+               if (desc->chip != chip) {
+                       if (count != 0) {
+                               _gpio_chip_set_multiple(chip, mask, bits);
+                               memset(mask, 0, sizeof(mask));
+                               count = 0;
+                       }
+                       chip = desc->chip;

drivers/gpio/gpiolib.c static void _gpiod_set_raw_value(struct gpio_desc *desc, bool value) · line 2405

Quoted 10 lines
drivers/gpio/gpiolib.c +10 -0
+               }
+               /* collect all normal outputs belonging to the same chip */
+               /* open drain and open source outputs are set individually */
+               trace_gpio_value(desc_to_gpio(desc), 0, value);
+               if (test_bit(FLAG_OPEN_DRAIN, &desc->flags)) {
+                       _gpio_set_open_drain_value(desc, value);
+               } else if (test_bit(FLAG_OPEN_SOURCE, &desc->flags)) {
+                       _gpio_set_open_source_value(desc, value);
+               } else {
+                       mask[hwgpio/32] |= (1 << (hwgpio % 32));

__set_bit(&mask[hwgpio / 32], BIT(hwgpio % 32))

drivers/gpio/gpiolib.c static void _gpiod_set_raw_value(struct gpio_desc *desc, bool value) · line 2407

Quoted 2 lines
drivers/gpio/gpiolib.c +2 -0
+                       if (value) {
+                               bits[hwgpio/32] |= (1 << (hwgpio % 32));

__set_bit(&bits[hwgpio / 32], BIT(hwgpio % 32))

drivers/gpio/gpiolib.c static void _gpiod_set_raw_value(struct gpio_desc *desc, bool value) · line 2409

Quoted 2 lines
drivers/gpio/gpiolib.c +2 -0
+                       } else {
+                               bits[hwgpio/32] &= ~(1 << (hwgpio % 32));

__clear_bit(&bits[hwgpio / 32], BIT(hwgpio % 32));

Quoted 13 lines
drivers/gpio/gpiolib.c +9 -0
+                       }
+                       count++;
+               }
+       }
+       if (count != 0) {
+               _gpio_chip_set_multiple(chip, mask, bits);
+       }
+}
+
 /**
  * gpiod_set_raw_value() - assign a gpio's raw value
  * @desc: gpio whose value will be assigned

drivers/gpio/gpiolib.c void gpiod_set_value(struct gpio_desc *desc, int value) · line 2464

Quoted 4 lines
drivers/gpio/gpiolib.c +1 -0
@@ -2390,6 +2461,30 @@ void gpiod_set_value(struct gpio_desc *desc, int value)
 EXPORT_SYMBOL_GPL(gpiod_set_value);
 
 /**
+ * gpiod_set_raw_array() - assign values to an array of GPIOs

Miss documentation for array_size here.

Quoted 6 lines
drivers/gpio/gpiolib.c +6 -0
+ * @desc_array: array of GPIO descriptors whose values will be assigned
+ * @value_array: array of values to assign
+ *
+ * Set the raw values of the GPIOs, i.e. the values of the physical lines
+ * without regard for their ACTIVE_LOW status.
+ *

drivers/gpio/gpiolib.c void gpiod_set_value(struct gpio_desc *desc, int value) · line 2480

Quoted 10 lines
drivers/gpio/gpiolib.c +10 -0
+ * This function should be called from contexts where we cannot sleep, and will
+ * complain if the GPIO chip functions potentially sleep.
+ */
+void gpiod_set_raw_array(unsigned int array_size,
+                        struct gpio_desc **desc_array, int *value_array)
+{
+       if (!desc_array)
+               return;
+       if (!desc_array[0])
+               return;

What if array_size == 0? This seems to be more important to check that the value of desc_array[0].

Quoted 11 lines
drivers/gpio/gpiolib.c +7 -0
+       /* Should be using gpiod_set_raw_array_cansleep() */
+       WARN_ON(desc_array[0]->chip->can_sleep);
+       _gpiod_set_raw_array(array_size, desc_array, value_array);
+}
+EXPORT_SYMBOL_GPL(gpiod_set_raw_array);
+
+/**
  * gpiod_cansleep() - report whether gpio value access may sleep
  * @desc: gpio to check
  *

drivers/gpio/gpiolib.c void gpiod_set_value_cansleep(struct gpio_desc *desc, int value) · line 2657

Quoted 4 lines
drivers/gpio/gpiolib.c +1 -0
@@ -2559,6 +2654,27 @@ void gpiod_set_value_cansleep(struct gpio_desc *desc, int value)
 EXPORT_SYMBOL_GPL(gpiod_set_value_cansleep);
 
 /**
+ * gpiod_set_raw_array_cansleep() - assign values to an array of GPIOs

array_size documentation missing here as well.

Quoted 5 lines
drivers/gpio/gpiolib.c +5 -0
+ * @desc_array: array of GPIO descriptors whose values will be assigned
+ * @value_array: array of values to assign
+ *
+ * Set the raw values of the GPIOs, i.e. the values of the physical lines
+ * without regard for their ACTIVE_LOW status.

drivers/gpio/gpiolib.c void gpiod_set_value_cansleep(struct gpio_desc *desc, int value) · line 2672

Quoted 10 lines
drivers/gpio/gpiolib.c +10 -0
+ *
+ * This function is to be called from contexts that can sleep.
+ */
+void gpiod_set_raw_array_cansleep(unsigned int array_size,
+                                 struct gpio_desc **desc_array,
+                                 int *value_array)
+{
+       might_sleep_if(extra_checks);
+       if (!desc_array)
+               return;

What happened to the other test here?

Quoted 71 lines
drivers/gpio/gpiolib.c +5 -0
+       _gpiod_set_raw_array(array_size, desc_array, value_array);
+}
+EXPORT_SYMBOL_GPL(gpiod_set_raw_array_cansleep);
+
+/**
  * gpiod_add_lookup_table() - register GPIO device consumers
  * @table: table of consumers to register
  */
include/linux/gpio/consumer.h +18 -0
index bed128e..1d0bab3 100644
@@ -42,12 +42,17 @@ int gpiod_get_value(const struct gpio_desc *desc);
 void gpiod_set_value(struct gpio_desc *desc, int value);
 int gpiod_get_raw_value(const struct gpio_desc *desc);
 void gpiod_set_raw_value(struct gpio_desc *desc, int value);
+void gpiod_set_raw_array(unsigned int array_size,
+                        struct gpio_desc **desc_array, int *value_array);
 
 /* Value get/set from sleeping context */
 int gpiod_get_value_cansleep(const struct gpio_desc *desc);
 void gpiod_set_value_cansleep(struct gpio_desc *desc, int value);
 int gpiod_get_raw_value_cansleep(const struct gpio_desc *desc);
 void gpiod_set_raw_value_cansleep(struct gpio_desc *desc, int value);
+void gpiod_set_raw_array_cansleep(unsigned int array_size,
+                                 struct gpio_desc **desc_array,
+                                 int *value_array);
 
 int gpiod_set_debounce(struct gpio_desc *desc, unsigned debounce);
 
@@ -150,6 +155,12 @@ static inline void gpiod_set_raw_value(struct gpio_desc *desc, int value)
        /* GPIO can never have been requested */
        WARN_ON(1);
 }
+void gpiod_set_raw_array(unsigned int array_size,
+                        struct gpio_desc **desc_array, int *value_array)
+{
+       /* GPIO can never have been requested */
+       WARN_ON(1);
+}
 
 static inline int gpiod_get_value_cansleep(const struct gpio_desc *desc)
 {
@@ -174,6 +185,13 @@ static inline void gpiod_set_raw_value_cansleep(struct gpio_desc *desc,
        /* GPIO can never have been requested */
        WARN_ON(1);
 }
+void gpiod_set_raw_array_cansleep(unsigned int array_size,
+                                 struct gpio_desc **desc_array,
+                                 int *value_array)
+{
+       /* GPIO can never have been requested */
+       WARN_ON(1);
+}
 
 static inline int gpiod_set_debounce(struct gpio_desc *desc, unsigned debounce)
 {
include/linux/gpio/driver.h +1 -0
index 1827b43..d7968c8 100644
@@ -32,6 +32,7 @@ struct seq_file;
  * @get: returns value for signal "offset"; for output signals this
  *     returns either the value actually sensed, or zero
  * @set: assigns output value for signal "offset"
+ * @set_multiple: assigns output values for multiple signals defined by "mask"
  * @set_debounce: optional hook for setting debounce time for specified gpio in
  *      interrupt triggered gpio chips
  * @to_irq: optional hook supporting non-static gpio_to_irq() mappings;

include/linux/gpio/driver.h struct gpio_chip { · line 92

Quoted 8 lines
include/linux/gpio/driver.h +2 -0
@@ -84,6 +85,8 @@ struct gpio_chip {
                                                unsigned offset);
        void                    (*set)(struct gpio_chip *chip,
                                                unsigned offset, int value);
+       void                    (*set_multiple)(struct gpio_chip *chip,
+                                               u32 *mask, u32 *bits);
        int                     (*set_debounce)(struct gpio_chip *chip,
                                                unsigned offset,
                                                unsigned debounce);

All in all I think this has good chances to be merged, once the issues are addressed. The issue of setting multiple GPIOs simulatenously comes regularly, and the performance improvement is undeniable here.

Alex.

#2 lore raw
In reply to Linus Walleij
Quoted 5 lines · Linus Walleij

include/linux/gpio/driver.h struct gpio_chip { · line 89

Quoted 2 lines · Rojhalat Ibrahim
include/linux/gpio/driver.h +2 -0
+       void                    (*set_multiple)(struct gpio_chip *chip,
+                                               u32 *mask, u32 *bits);
Quoted 8 lines

This sets the chunk size to 32bits which means that any GPIO controller with say 8bit registers will get a complex demuxing scheme.

But thinking of it I think it's a reasonable compromise given that so many GPIO drivers are actually 32bit.

However some of the real slow I2C expander GPIOs are 8bit.

We can probably librify the demuxing code if we need it, though a lot of those devices only have 8 GPIOs in the first place which makes life a lot simpler since everything will always be in the same register anyway.

Overall the interface here looks good modulo your concerns about ARCH_NR_GPIOs.

#3 lore raw
In reply to Linus Walleij
Quoted 33 lines · On Thursday 29 May 2014 12:10:02 Linus Walleij wrote:
Quoted 23 lines · Rojhalat Ibrahim

Introduce a new function gpiod_set_raw_array to the consumer interface which allows setting multiple outputs with just one function call. Also add an optional set_multiple function to the driver interface. Without an implementation of that function in the chip driver outputs are set sequentially.

Implementing the set_multiple function in a chip driver allows for:
- Improved performance for certain use cases. The original motivation for this was the task of configuring an FPGA. In that specific case, where 9 GPIO lines have to be set many times, configuration time goes down from 48 s to 19 s when using the new function.
- Simultaneous glitch-free setting of multiple pins on any kind of parallel bus attached to GPIOs provided they all reside on the same chip and bank.

Limitations:
- Performance is only improved for normal high-low outputs. Open drain and open source outputs are always set separately from each other. Those kinds of outputs could probably be accelerated in a similar way if we could forgo the error checking when setting GPIO directions.
- There is no gpiod_set_array function that regards the ACTIVE_LOW bits. The raw function should be sufficient for many use cases. So I avoided the code duplication the other functions would require.

Quoted 7 lines

---
Change log:
v3: - add documentation
- change commit message
v2: - use descriptor interface
- allow arbitrary groups of GPIOs spanning multiple chips

Quoted 3 lines

This concept has been brought up before. Please keep Grant Likley in the loop on these postings as he has some history with this.

Will do.

Quoted 5 lines

As this is a speed optimization basically, do you have performance numbers? Like how much quicker is your code in some critical usecase as measured by perf or throughput whatever before and after doing this?

As mentioned in the commit message my use case is the configuration of an FPGA. Using the new function configuration time goes down from 48 s to 19 s.

Quoted 4 lines

Notice that the SPI bitbang driver in drivers/spi/spi-gpio.c was one of the most important consumers of this API IIRC. So I'm CC:ing Mark Brown.

Quoted 11 lines

Documentation/gpio/consumer.txt The active-low state of a GPIO can also be queried using the following call: · line 175

Quoted 8 lines
Documentation/gpio/consumer.txt +8 -0
+The following two functions set the raw output values of an array of GPIOs:
+
+       void gpiod_set_raw_array(unsigned int array_size,
+                                struct gpio_desc **desc_array,
+                                int *value_array)
+       void gpiod_set_raw_array_cansleep(unsigned int array_size,
+                                         struct gpio_desc **desc_array,
+                                         int *value_array)

So this interface looks quite nice.

Thanks.

Quoted 5 lines

I don't see why the complex loop in the raw setter below cannot actually also handle non-raw (cooked? hehe) values with some single-liner to invert the value if it is active low.

I will look into that. I did not want to invert the active-low values in the array first and then pass the array of partly inverted values to the _gpiod_set_raw_array function because that would change the array values passed by the user.
Another way to handle the non-raw values would of course be to do it in the same function as the raw values. That would require additional checks and would possibly degrade performance for the raw case. But the performance impact could also be negligible. So as I said I will look into it.

Quoted 5 lines
Quoted 1 line

+static void _gpio_chip_set_multiple(struct gpio_chip *chip,

I hate _underscored function names, just call it
gpio_chip_set_multiple_offsets() or whatever.

Ok.

Quoted 8 lines

drivers/gpio/gpiolib.c static void _gpiod_set_raw_value(struct gpio_desc *desc, bool value) · line 2351

Quoted 3 lines
drivers/gpio/gpiolib.c +3 -0
+                                   u32 mask[ARCH_NR_GPIOS/32],
+                                   u32 bits[ARCH_NR_GPIOS/32])
+{

First: NO, you NEVER tie any code into ARCH_NR_GPIOS because that is something we want to get rid of. Just use regular pointers, add a count argument if need be.

Will do.

Quoted 6 lines

drivers/gpio/gpiolib.c static void _gpiod_set_raw_value(struct gpio_desc *desc, bool value) · line 2353

Quoted 2 lines
drivers/gpio/gpiolib.c +2 -0
+       if (chip->set_multiple) {
+               chip->set_multiple(chip, mask, bits);

Simple and quick OK. But even this is making a quite nasty assumption...

Could you elaborate? What's the nasty assumption?

Quoted 8 lines

drivers/gpio/gpiolib.c static void _gpiod_set_raw_value(struct gpio_desc *desc, bool value) · line 2356

Quoted 3 lines
drivers/gpio/gpiolib.c +3 -0
+       } else {
+               int i;
+               for (i = 0; i < ARCH_NR_GPIOS; i++) {

As I said you cannot depend on ARCH_NR_GPIOS and not introduce more dependencies to it. Figure out something else. Like using chip->ngpio to iterate.

Ok.

Quoted 15 lines
Quoted 4 lines
drivers/gpio/gpiolib.c +4 -0
+                       if (i > chip->ngpio - 1)
+                               break;
+                       if (mask[i/32] == 0) {
+                               /* skip ahead */

drivers/gpio/gpiolib.c static void _gpiod_set_raw_value(struct gpio_desc *desc, bool value) · line 2370

Quoted 10 lines
drivers/gpio/gpiolib.c +10 -0
+                               i = (i/32 + 1) * 32 - 1;
+                               continue;
+                       }
+                       if (mask[i/32] & (1 << (i % 32))) {
+                               chip->set(chip, i, (bits[i/32] >> (i % 32)) & 1);
+                               mask[i/32] &= ~(1 << (i % 32));
+                       }
+               }
+       }
+}
Quoted 4 lines

This code is a bit convoluted but I *guess* the idea is to iterate over the 32 bits in the argument word by word. Add some comments describing what's going on.

Will do.

Quoted 4 lines

Some chips have 8bit or 16bit registers actually but AFAICT that is not what this is about, rather about the fact that the function takes 32bit arguments.

Right.

Quoted 4 lines
Quoted 1 line

+static void _gpiod_set_raw_array(unsigned int array_size,

No underscored function name.

Ok.

Quoted 9 lines

drivers/gpio/gpiolib.c static void _gpiod_set_raw_value(struct gpio_desc *desc, bool value) · line 2378

Quoted 6 lines
drivers/gpio/gpiolib.c +6 -0
+                                struct gpio_desc **desc_array,
+                                int *value_array)
+{
+       struct gpio_chip *chip = desc_array[0]->chip;
+       u32 mask[ARCH_NR_GPIOS/32];
+       u32 bits[ARCH_NR_GPIOS/32];

Again dependency to ARCH_NR_GPIOS. Don't do it.

Ok.

Quoted 5 lines
Quoted 5 lines
drivers/gpio/gpiolib.c +5 -0
+       int count = 0;
+       int i;
+
+       memset(mask, 0, sizeof(mask));
+       for (i = 0; i < array_size; i++) {
Quoted 9 lines

drivers/gpio/gpiolib.c static void _gpiod_set_raw_value(struct gpio_desc *desc, bool value) · line 2389

Quoted 6 lines
drivers/gpio/gpiolib.c +6 -0
+               struct gpio_desc *desc = desc_array[i];
+               int hwgpio = gpio_chip_hwgpio(desc);
+               int value = value_array[i];
+
+               /* another chip; push collected bits to outputs */
+               if (desc->chip != chip) {

Clever logic!

Thanks.

Quoted 24 lines
Quoted 13 lines
drivers/gpio/gpiolib.c +13 -0
+                       if (count != 0) {
+                               _gpio_chip_set_multiple(chip, mask, bits);
+                               memset(mask, 0, sizeof(mask));
+                               count = 0;
+                       }
+                       chip = desc->chip;
+               }
+               /* collect all normal outputs belonging to the same chip */
+               /* open drain and open source outputs are set individually */
+               trace_gpio_value(desc_to_gpio(desc), 0, value);
+               if (test_bit(FLAG_OPEN_DRAIN, &desc->flags)) {
+                       _gpio_set_open_drain_value(desc, value);
+               } else if (test_bit(FLAG_OPEN_SOURCE, &desc->flags)) {

drivers/gpio/gpiolib.c static void _gpiod_set_raw_value(struct gpio_desc *desc, bool value) · line 2412

Quoted 10 lines
drivers/gpio/gpiolib.c +10 -0
+                       _gpio_set_open_source_value(desc, value);
+               } else {
+                       mask[hwgpio/32] |= (1 << (hwgpio % 32));
+                       if (value) {
+                               bits[hwgpio/32] |= (1 << (hwgpio % 32));
+                       } else {
+                               bits[hwgpio/32] &= ~(1 << (hwgpio % 32));
+                       }
+                       count++;
+               }
Quoted 2 lines

This is also real smart and nice code.

Thanks again.

Quoted 5 lines

The assumption is that this iteration hotloop will be quicker to run, and the driver can take shortcuts improving performance. As mentione above we need some proof of that as it complicates the code a lot for this performance improvement.

See above.

Quoted 34 lines
Quoted 6 lines
drivers/gpio/gpiolib.c +6 -0
+       }
+       if (count != 0) {
+               _gpio_chip_set_multiple(chip, mask, bits);
+       }
+}
+

(...)

Quoted 15 lines

static inline int gpiod_set_debounce(struct gpio_desc *desc, unsigned debounce) {

include/linux/gpio/driver.h +1 -0
index 1827b43..d7968c8 100644
@@ -32,6 +32,7 @@ struct seq_file;
  * @get: returns value for signal "offset"; for output signals this
  *     returns either the value actually sensed, or zero
  * @set: assigns output value for signal "offset"
+ * @set_multiple: assigns output values for multiple signals defined by "mask"
  * @set_debounce: optional hook for setting debounce time for specified gpio in
  *      interrupt triggered gpio chips
  * @to_irq: optional hook supporting non-static gpio_to_irq() mappings;

include/linux/gpio/driver.h struct gpio_chip { · line 89

Quoted 5 lines
include/linux/gpio/driver.h +2 -0
@@ -84,6 +85,8 @@ struct gpio_chip {
                                                unsigned offset);
        void                    (*set)(struct gpio_chip *chip,
                                                unsigned offset, int value);
+       void                    (*set_multiple)(struct gpio_chip *chip,
+                                               u32 *mask, u32 *bits);

This sets the chunk size to 32bits which means that any GPIO controller with say 8bit registers will get a complex demuxing scheme.

Quoted 5 lines

But thinking of it I think it's a reasonable compromise given that so many GPIO drivers are actually 32bit.

However some of the real slow I2C expander GPIOs are 8bit.

So I'll leave the chunk size at 32 bits.

Quoted 3 lines

Yours,
Linus Walleij

Thanks for the review. I'll send a new revision of the patch soon.

Rojhalat

#5 lore raw
In reply to Alexandre Courbot
Quoted 24 lines · On Sunday 01 June 2014 18:36:32 Alexandre Courbot wrote:
Quoted 14 lines · Rojhalat Ibrahim

Introduce a new function gpiod_set_raw_array to the consumer interface which allows setting multiple outputs with just one function call. Also add an optional set_multiple function to the driver interface. Without an implementation of that function in the chip driver outputs are set sequentially.

Implementing the set_multiple function in a chip driver allows for:
- Improved performance for certain use cases. The original motivation for this was the task of configuring an FPGA. In that specific case, where 9 GPIO lines have to be set many times, configuration time goes down from 48 s to 19 s when using the new function.
- Simultaneous glitch-free setting of multiple pins on any kind of parallel bus attached to GPIOs provided they all reside on the same chip and bank.

Quoted 8 lines

Limitations:
- Performance is only improved for normal high-low outputs. Open drain and open source outputs are always set separately from each other. Those kinds of outputs could probably be accelerated in a similar way if we could forgo the error checking when setting GPIO directions.
- There is no gpiod_set_array function that regards the ACTIVE_LOW bits. The raw function should be sufficient for many use cases. So I avoided the code duplication the other functions would require.

Quoted 4 lines

How much effort would it be to also implement this function? IIUC it should just require one extra pass of the values array prior to calling gpiod_set_raw_array().

I did not want to do that because that would change the array values passed by the user. Or would that be acceptable?

Quoted 67 lines
Quoted 29 lines

---
Change log:
v3: - add documentation
- change commit message
v2: - use descriptor interface
- allow arbitrary groups of GPIOs spanning multiple chips

 Documentation/gpio/consumer.txt |  17 ++++++
 drivers/gpio/gpiolib.c          | 116 ++++++++++++++++++++++++++++++++++++++++
 include/linux/gpio/consumer.h   |  18 +++++++
 include/linux/gpio/driver.h     |   3 ++
 4 files changed, 154 insertions(+)
Documentation/gpio/consumer.txt +6 -0
index 09854fe..affcd9b 100644
@@ -163,6 +163,23 @@ The active-low state of a GPIO can also be queried using the following call:
 Note that these functions should only be used with great moderation ; a driver
 should not have to care about the physical line level.
 
+Set multiple GPIO outputs with a single function call
+-----------------------------------------------------
+The following two functions set the raw output values of an array of GPIOs:
+
+       void gpiod_set_raw_array(unsigned int array_size,
+                                struct gpio_desc **desc_array,

Documentation/gpio/consumer.txt The active-low state of a GPIO can also be queried using the following call: · line 181

Quoted 10 lines
Documentation/gpio/consumer.txt +10 -0
+                                int *value_array)
+       void gpiod_set_raw_array_cansleep(unsigned int array_size,
+                                         struct gpio_desc **desc_array,
+                                         int *value_array)
+
+The array can be an arbitrary set of GPIOs. The functions will try to set
+GPIOs belonging to the same bank or chip simultaneously if supported by the
+corresponding chip driver. In that case a significantly improved performance
+can be expected. If simultaneous setting is not possible the GPIOs will be set
+sequentially.

Nice and clean interface, taking advantage of the descriptor interface.

Quoted 11 lines
Documentation/gpio/consumer.txt +1 -0
+
 GPIOs mapped to IRQs
 --------------------
 GPIO lines can quite often be used as IRQs. You can get the IRQ number
drivers/gpio/gpiolib.c +0 -0
index f48817d..ee67ef1 100644
@@ -2345,6 +2345,77 @@ static void _gpiod_set_raw_value(struct gpio_desc *desc, bool value)
                chip->set(chip, gpio_chip_hwgpio(desc), value);
 }

drivers/gpio/gpiolib.c static void _gpiod_set_raw_value(struct gpio_desc *desc, bool value) · line 2356

Quoted 10 lines
drivers/gpio/gpiolib.c +9 -0
 
+static void _gpio_chip_set_multiple(struct gpio_chip *chip,
+                                   u32 mask[ARCH_NR_GPIOS/32],
+                                   u32 bits[ARCH_NR_GPIOS/32])
+{
+       if (chip->set_multiple) {
+               chip->set_multiple(chip, mask, bits);
+       } else {
+               int i;
+               for (i = 0; i < ARCH_NR_GPIOS; i++) {

As Linus already said, please avoid using the deprecated ARCH_NR_GPIOS. chip->ngpio should be just as usable in your case...

Quoted 5 lines

drivers/gpio/gpiolib.c static void _gpiod_set_raw_value(struct gpio_desc *desc, bool value) · line 2358

Quoted 2 lines
drivers/gpio/gpiolib.c +2 -0
+                       if (i > chip->ngpio - 1)
+                               break;

... and it would allow you to remove that test.

Ok.

Quoted 9 lines

drivers/gpio/gpiolib.c static void _gpiod_set_raw_value(struct gpio_desc *desc, bool value) · line 2364

Quoted 6 lines
drivers/gpio/gpiolib.c +6 -0
+                       if (mask[i/32] == 0) {
+                               /* skip ahead */
+                               i = (i/32 + 1) * 32 - 1;
+                               continue;
+                       }
+                       if (mask[i/32] & (1 << (i % 32))) {

BIT(i % 32)? (and everywhere else where it applies)

Will do.

Quoted 4 lines

drivers/gpio/gpiolib.c static void _gpiod_set_raw_value(struct gpio_desc *desc, bool value) · line 2365

Quoted 1 line
drivers/gpio/gpiolib.c +1 -0
+                               chip->set(chip, i, (bits[i/32] >> (i % 32)) & 1);

Why are you putting a space around the operator in "i % 32" but not in "i/32" ?

I will do it consistently in the next revision.

Quoted 7 lines

drivers/gpio/gpiolib.c static void _gpiod_set_raw_value(struct gpio_desc *desc, bool value) · line 2366

Quoted 1 line
drivers/gpio/gpiolib.c +1 -0
+                               mask[i/32] &= ~(1 << (i % 32));

There are lots of mask[i/32] and bits[i/32] here. I'm sure the compiler will optimize them away, but for code clarity it might be worth to have each set of u32 be processed by another (inline) function.

I'll look into that.

Quoted 37 lines

drivers/gpio/gpiolib.c static void _gpiod_set_raw_value(struct gpio_desc *desc, bool value) · line 2378

Quoted 12 lines
drivers/gpio/gpiolib.c +12 -0
+                       }
+               }
+       }
+}
+
+static void _gpiod_set_raw_array(unsigned int array_size,
+                                struct gpio_desc **desc_array,
+                                int *value_array)
+{
+       struct gpio_chip *chip = desc_array[0]->chip;
+       u32 mask[ARCH_NR_GPIOS/32];
+       u32 bits[ARCH_NR_GPIOS/32];

If ARCH_NR_GPIOS is not a multiple of 32, your array will miss one element. You should use DIV_ROUND_UP(ARCH_NR_GPIOS, 32), but even better, let's not use ARCH_NR_GPIOS at all.

Maybe someone will kill me for suggesting this, but I wonder if you could not use C99's VLA-on-stack feature here? Please rap my knuckles if this is taboo in the kernel, but something like this may work (untested though):

i = 0;

while (i < array_size) {
       struct gpio_chip *chip = desc_array[i]->chip;
       u32 mask[DIV_ROUND_UP(chip->ngpios, 32)];
        ....

        do {
             /* Process values for GPIOs of the same chip */
        } while (++i < array_size && desc_array[i]->chip != chip);

        _gpio_chip_set_multiple(...);
    }
}
Quoted 4 lines

Something like this. It should also avoid some of the repetitions in your code. That is, *if* the stack VLAs are usable at all and someone does not fall on us shouting how evil this is.

I'll look into that, too.

Quoted 21 lines
Quoted 21 lines
drivers/gpio/gpiolib.c +21 -0
+       int count = 0;
+       int i;
+
+       memset(mask, 0, sizeof(mask));
+       for (i = 0; i < array_size; i++) {
+               struct gpio_desc *desc = desc_array[i];
+               int hwgpio = gpio_chip_hwgpio(desc);
+               int value = value_array[i];
+
+               /* another chip; push collected bits to outputs */
+               if (desc->chip != chip) {
+                       if (count != 0) {
+                               _gpio_chip_set_multiple(chip, mask, bits);
+                               memset(mask, 0, sizeof(mask));
+                               count = 0;
+                       }
+                       chip = desc->chip;
+               }
+               /* collect all normal outputs belonging to the same chip */
+               /* open drain and open source outputs are set individually */
+               trace_gpio_value(desc_to_gpio(desc), 0, value);
Quoted 9 lines

drivers/gpio/gpiolib.c static void _gpiod_set_raw_value(struct gpio_desc *desc, bool value) · line 2405

Quoted 6 lines
drivers/gpio/gpiolib.c +6 -0
+               if (test_bit(FLAG_OPEN_DRAIN, &desc->flags)) {
+                       _gpio_set_open_drain_value(desc, value);
+               } else if (test_bit(FLAG_OPEN_SOURCE, &desc->flags)) {
+                       _gpio_set_open_source_value(desc, value);
+               } else {
+                       mask[hwgpio/32] |= (1 << (hwgpio % 32));

__set_bit(&mask[hwgpio / 32], BIT(hwgpio % 32))

Ok.

Quoted 5 lines

drivers/gpio/gpiolib.c static void _gpiod_set_raw_value(struct gpio_desc *desc, bool value) · line 2407

Quoted 2 lines
drivers/gpio/gpiolib.c +2 -0
+                       if (value) {
+                               bits[hwgpio/32] |= (1 << (hwgpio % 32));

__set_bit(&bits[hwgpio / 32], BIT(hwgpio % 32))

Ok.

Quoted 5 lines

drivers/gpio/gpiolib.c static void _gpiod_set_raw_value(struct gpio_desc *desc, bool value) · line 2409

Quoted 2 lines
drivers/gpio/gpiolib.c +2 -0
+                       } else {
+                               bits[hwgpio/32] &= ~(1 << (hwgpio % 32));

__clear_bit(&bits[hwgpio / 32], BIT(hwgpio % 32));

Ok.

Quoted 15 lines
Quoted 15 lines
drivers/gpio/gpiolib.c +9 -0
+                       }
+                       count++;
+               }
+       }
+       if (count != 0) {
+               _gpio_chip_set_multiple(chip, mask, bits);
+       }
+}
+
 /**
  * gpiod_set_raw_value() - assign a gpio's raw value
  * @desc: gpio whose value will be assigned
@@ -2390,6 +2461,30 @@ void gpiod_set_value(struct gpio_desc *desc, int value)
 EXPORT_SYMBOL_GPL(gpiod_set_value);
 
Quoted 5 lines

drivers/gpio/gpiolib.c void gpiod_set_value(struct gpio_desc *desc, int value) · line 2464

Quoted 2 lines
drivers/gpio/gpiolib.c +1 -0
 /**
+ * gpiod_set_raw_array() - assign values to an array of GPIOs

Miss documentation for array_size here.

Will fix that in the next revision.

Quoted 11 lines
Quoted 11 lines
drivers/gpio/gpiolib.c +11 -0
+ * @desc_array: array of GPIO descriptors whose values will be assigned
+ * @value_array: array of values to assign
+ *
+ * Set the raw values of the GPIOs, i.e. the values of the physical lines
+ * without regard for their ACTIVE_LOW status.
+ *
+ * This function should be called from contexts where we cannot sleep, and will
+ * complain if the GPIO chip functions potentially sleep.
+ */
+void gpiod_set_raw_array(unsigned int array_size,
+                        struct gpio_desc **desc_array, int *value_array)
Quoted 9 lines

drivers/gpio/gpiolib.c void gpiod_set_value(struct gpio_desc *desc, int value) · line 2480

Quoted 5 lines
drivers/gpio/gpiolib.c +5 -0
+{
+       if (!desc_array)
+               return;
+       if (!desc_array[0])
+               return;

What if array_size == 0? This seems to be more important to check that the value of desc_array[0].

Will add a check in the next revision.
desc_array[0] is checked because it is used here:

            WARN_ON(desc_array[0]->chip->can_sleep)
Quoted 13 lines
Quoted 13 lines
drivers/gpio/gpiolib.c +7 -0
+       /* Should be using gpiod_set_raw_array_cansleep() */
+       WARN_ON(desc_array[0]->chip->can_sleep);
+       _gpiod_set_raw_array(array_size, desc_array, value_array);
+}
+EXPORT_SYMBOL_GPL(gpiod_set_raw_array);
+
+/**
  * gpiod_cansleep() - report whether gpio value access may sleep
  * @desc: gpio to check
  *
@@ -2559,6 +2654,27 @@ void gpiod_set_value_cansleep(struct gpio_desc *desc, int value)
 EXPORT_SYMBOL_GPL(gpiod_set_value_cansleep);
 
Quoted 5 lines

drivers/gpio/gpiolib.c void gpiod_set_value_cansleep(struct gpio_desc *desc, int value) · line 2657

Quoted 2 lines
drivers/gpio/gpiolib.c +1 -0
 /**
+ * gpiod_set_raw_array_cansleep() - assign values to an array of GPIOs

array_size documentation missing here as well.

Will fix that in the next revision.

Quoted 9 lines
Quoted 9 lines
drivers/gpio/gpiolib.c +9 -0
+ * @desc_array: array of GPIO descriptors whose values will be assigned
+ * @value_array: array of values to assign
+ *
+ * Set the raw values of the GPIOs, i.e. the values of the physical lines
+ * without regard for their ACTIVE_LOW status.
+ *
+ * This function is to be called from contexts that can sleep.
+ */
+void gpiod_set_raw_array_cansleep(unsigned int array_size,
Quoted 9 lines

drivers/gpio/gpiolib.c void gpiod_set_value_cansleep(struct gpio_desc *desc, int value) · line 2672

Quoted 6 lines
drivers/gpio/gpiolib.c +6 -0
+                                 struct gpio_desc **desc_array,
+                                 int *value_array)
+{
+       might_sleep_if(extra_checks);
+       if (!desc_array)
+               return;

What happened to the other test here?

desc_array[0] is not checked here because it is not used in that function. I will add a check for array_size == 0 in the next revision.

Quoted 84 lines
Quoted 71 lines
drivers/gpio/gpiolib.c +5 -0
+       _gpiod_set_raw_array(array_size, desc_array, value_array);
+}
+EXPORT_SYMBOL_GPL(gpiod_set_raw_array_cansleep);
+
+/**
  * gpiod_add_lookup_table() - register GPIO device consumers
  * @table: table of consumers to register
  */
include/linux/gpio/consumer.h +18 -0
index bed128e..1d0bab3 100644
@@ -42,12 +42,17 @@ int gpiod_get_value(const struct gpio_desc *desc);
 void gpiod_set_value(struct gpio_desc *desc, int value);
 int gpiod_get_raw_value(const struct gpio_desc *desc);
 void gpiod_set_raw_value(struct gpio_desc *desc, int value);
+void gpiod_set_raw_array(unsigned int array_size,
+                        struct gpio_desc **desc_array, int *value_array);
 
 /* Value get/set from sleeping context */
 int gpiod_get_value_cansleep(const struct gpio_desc *desc);
 void gpiod_set_value_cansleep(struct gpio_desc *desc, int value);
 int gpiod_get_raw_value_cansleep(const struct gpio_desc *desc);
 void gpiod_set_raw_value_cansleep(struct gpio_desc *desc, int value);
+void gpiod_set_raw_array_cansleep(unsigned int array_size,
+                                 struct gpio_desc **desc_array,
+                                 int *value_array);
 
 int gpiod_set_debounce(struct gpio_desc *desc, unsigned debounce);
 
@@ -150,6 +155,12 @@ static inline void gpiod_set_raw_value(struct gpio_desc *desc, int value)
        /* GPIO can never have been requested */
        WARN_ON(1);
 }
+void gpiod_set_raw_array(unsigned int array_size,
+                        struct gpio_desc **desc_array, int *value_array)
+{
+       /* GPIO can never have been requested */
+       WARN_ON(1);
+}
 
 static inline int gpiod_get_value_cansleep(const struct gpio_desc *desc)
 {
@@ -174,6 +185,13 @@ static inline void gpiod_set_raw_value_cansleep(struct gpio_desc *desc,
        /* GPIO can never have been requested */
        WARN_ON(1);
 }
+void gpiod_set_raw_array_cansleep(unsigned int array_size,
+                                 struct gpio_desc **desc_array,
+                                 int *value_array)
+{
+       /* GPIO can never have been requested */
+       WARN_ON(1);
+}
 
 static inline int gpiod_set_debounce(struct gpio_desc *desc, unsigned debounce)
 {
include/linux/gpio/driver.h +1 -0
index 1827b43..d7968c8 100644
@@ -32,6 +32,7 @@ struct seq_file;
  * @get: returns value for signal "offset"; for output signals this
  *     returns either the value actually sensed, or zero
  * @set: assigns output value for signal "offset"
+ * @set_multiple: assigns output values for multiple signals defined by "mask"
  * @set_debounce: optional hook for setting debounce time for specified gpio in
  *      interrupt triggered gpio chips
  * @to_irq: optional hook supporting non-static gpio_to_irq() mappings;

include/linux/gpio/driver.h struct gpio_chip { · line 92

Quoted 8 lines
include/linux/gpio/driver.h +2 -0
@@ -84,6 +85,8 @@ struct gpio_chip {
                                                unsigned offset);
        void                    (*set)(struct gpio_chip *chip,
                                                unsigned offset, int value);
+       void                    (*set_multiple)(struct gpio_chip *chip,
+                                               u32 *mask, u32 *bits);
        int                     (*set_debounce)(struct gpio_chip *chip,
                                                unsigned offset,
                                                unsigned debounce);

All in all I think this has good chances to be merged, once the issues are addressed. The issue of setting multiple GPIOs simulatenously comes regularly, and the performance improvement is undeniable here.

Quoted 2 lines

Alex.

Thanks for the review. I'll send a new revision of the patch soon.

Rojhalat