How to request GPIO interrupt from i2c io expander linux (fails with -EINVAL)

user_8378607 0
Viewed 1131

I'm developing a kernel module that needs to handle interrupts from 4 GPIOs, using an IO expander (MCP23008). I am working on a Raspberry Pi 3B+ with kernel 5.10.1-v7 (buildroot image). The module (mymodule) works as intended when using the "normal" GPIOs from the 40 pin header. However, when I try to use GPIOs from the pinctrl-mcp23s08 module, the request_interrupt function fails and returns -22 (EINVAL).

What am I missing? It seems to me everything is in place to request an interrupt from the expanded GPIOs. Other similar threads point to the IRQF_SHARED flag being used with NULL in the 5th argument of request_interrupt, but that is not my case.

Here's the relevant device-tree snippets:

/* for the io expander (mcp23s08) module */
&i2c1 { compatible = "brcm,bcm2835-i2c";
        pinctrl-names = "default";
        pinctrl-0 = <&i2c1_pins>;
        clock-frequency = <100000>;
        status="okay";

        mcp23008: mcp23008@20 {
                compatible = "microchip,mcp23008";
                reg=<0x20>;      /* i2c slave address */
                gpio-controller; /* mark the node as gpio-controller */
                #gpio-cells=<2>; /* pin number and flags */
                interrupt-parent = <&gpio>;
                interrupt-controller; /* mark the node as interrupt-controller */
                #interrupt-cells=<2>; /* pin number and flags */
                interrupts = <16 IRQ_TYPE_LEVEL_LOW>;
                status="okay";
        };
};

/* for mymodule */
/ {
        compatible = "raspberrypi,3-model-b-plus", "brcm,bcm2837";
        model = "Raspberry Pi 3 Model B+";

        mymodule {
                compatible = "myvendor,mymodule";
                gpios = <&mcp23008 0 GPIO_ACTIVE_HIGH>,
                        <&mcp23008 1 GPIO_ACTIVE_HIGH>,
                        <&mcp23008 2 GPIO_ACTIVE_HIGH>,
                        <&mcp23008 3 GPIO_ACTIVE_HIGH>;
                interrupt-parent = <&mcp23008>;
                interrupts = <0 IRQ_TYPE_LEVEL_HIGH>,
                             <1 IRQ_TYPE_LEVEL_HIGH>,
                             <2 IRQ_TYPE_LEVEL_HIGH>,
                             <3 IRQ_TYPE_LEVEL_HIGH>;
                status = "okay";
        };
};

I know the mcp23s08 module is inserted correctly at boot, since I can export GPIOs from sysfs and read their values. Also, in the init function of mymodule, the gpio_request_array function succeeds with the GPIOs given by the mcp23s08 module (gpio 496 to 499). Finally this line in /proc/interrupts tells me that the interrupt for the mcp23s08 driver (on gpio 16) is correctly assigned:

$ cat /proc/interrupts
           CPU0       CPU1       CPU2       CPU3
 50:       5505          0          0          0  ARMCTRL-level   1 Edge      3f00b880.mailbox
 51:         47          0          0          0  ARMCTRL-level   2 Edge      VCHIQ doorbell
 73:          0          0          0          0  ARMCTRL-level  48 Edge      bcm2708_fb DMA
 75:      12435          0          0          0  ARMCTRL-level  50 Edge      DMA IRQ
 77:        716          0          0          0  ARMCTRL-level  52 Edge      DMA IRQ
 78:         16          0          0          0  ARMCTRL-level  53 Edge      DMA IRQ
 81:          0          0          0          0  ARMCTRL-level  56 Edge      DMA IRQ
 86:        199          0          0          0  ARMCTRL-level  61 Edge      ttyS0
 89:     887966          0          0          0  ARMCTRL-level  64 Edge      dwc_otg, dwc_otg_pcd, dwc_otg_hcd:usb1
110:          2          0          0          0  ARMCTRL-level  85 Edge      3f804000.i2c
111:          0          0          0          0  ARMCTRL-level  86 Edge      3f204000.spi
113:        119          0          0          0  ARMCTRL-level  88 Edge      mmc0
119:     214231          0          0          0  ARMCTRL-level  94 Edge      mmc1
194:          0          0          0          0  bcm2836-timer   0 Edge      arch_timer
195:      91376     256895     932964      45993  bcm2836-timer   1 Edge      arch_timer
198:          0          0          0          0  bcm2836-pmu   9 Edge      arm-pmu
199:          1          0          0          0  pinctrl-bcm2835   4 Edge      pps.-1
200:          0          0          0          0  pinctrl-bcm2835  16 Level     1-0020
205:          0          0          0          0  lan78xx-irqs  17 Edge      usb-001:004:01
FIQ:              usb_fiq
IPI0:          0          0          0          0  CPU wakeup interrupts
IPI1:          0          0          0          0  Timer broadcast interrupts
IPI2:         91         73        100         88  Rescheduling interrupts
IPI3:       4671      20748      12983      31858  Function call interrupts
IPI4:          0          0          0          0  CPU stop interrupts
IPI5:          0          0          0          0  IRQ work interrupts
IPI6:          0          0          0          0  completion interrupts
Err:          0

Here's the relevant init code that fails to request the interrupt:

static int __init
mymodule_init(void)
{
        int i;
        int err;

        /* [...] */

        err = platform_driver_register(&gpio_driver);
        if (err) {
                printk(KERN_ERR "mymodule: failed to register platform driver\n");
                goto fail_platform_driver_register;
        }

        err = gpio_request_array(gpios, COUNT_OF(gpios));
        if (err != 0) {
                printk(KERN_ERR "mymodule: failed to request gpio array: %d\n", err);
                goto fail_gpio_request_array;
        }

        for (i = 0; i < COUNT_OF(irq_ids); ++i) {
                err = platform_get_irq(dev.platform_device, i);
                if (err > 0) {
                        irq_ids[i] = err;
                        printk(KERN_INFO "i=%d irq=%d\n", i, irq_ids[i]);
                } else {
                        printk(KERN_ERR "mymodule: gpio_to_irq failed i = %d\n", i);
                        goto fail_platform_get_irq;
                }
        }

        for (i = 0; i < COUNT_OF(irq_ids); ++i) {
                err = request_irq(
                                  irq_ids[i],
                                  (irq_handler_t) mymodule_irq_handler,
                                  IRQF_TRIGGER_HIGH,
                                  "mymodule_irq_handler",
                                  NULL
                                  );
                if (err) {
                        printk(KERN_ERR "mymodule: failed to request_irq at i=%d irq=%d: %d\n",
                               i, irq_ids[i], err);
                        goto fail_request_irq;
                }
        }

        /* success, return here */
        return 0;

        /* ommited: error handling here */
}

Finally, here's the dmesg output:

[   76.548689] i=0 irq=201
[   76.554473] i=1 irq=202
[   76.560189] i=2 irq=203
[   76.566033] i=3 irq=204
[   76.568525] mymodule: failed to request_irq at i=0 irq=201: -22
device-tree driver interrupt linux-kernel c
1 Answers

At least one reason for the failure is that the parent interrupt controller uses a threaded interrupt handler and so the child interrupt handlers also need to be threaded (these will be "nested" threaded interrupt handlers).

The incompatibility is tested in __setup_irq in "kernel/irq/manage.c":

    /*
     * Check whether the interrupt nests into another interrupt
     * thread.
     */
    nested = irq_settings_is_nested_thread(desc);
    if (nested) {
        if (!new->thread_fn) {
            ret = -EINVAL;
            goto out_mput;
        }
        /*
         * Replace the primary handler which was provided from
         * the driver for non nested interrupt handling by the
         * dummy function which warns when called.
         */
        new->handler = irq_nested_primary_handler;

(new->thread_fn is NULL when requesting a non-threaded IRQ handler. The above code results in a return value of -EINVAL from request_irq(). The new->handler = irq_nested_primary_handler; part is described as a footnote to the discussion of request_threaded_irq below.)

The request_irq call in the original code can be changed to the following to use a threaded IRQ handler:

                err = request_threaded_irq(
                                  irq_ids[i],
                                  NULL,
                                  mymodule_irq_handler,
                                  IRQF_TRIGGER_HIGH,
                                  "mymodule_irq_handler",
                                  NULL
                                  );

The main difference is the "hard-IRQ" handler has been set to NULL because it is not used for a purely threaded IRQ handler (including nested threaded IRQ handlers).1 (I also removed the type cast operator from (irq_handler_t) mymodule_irq_handler because that only serves to hide problems if mymodule_irq_handler has not been declared correctly.)

As an alternative to using request_threaded_irq, the request_any_context_irq function could be used instead as follows:

                err = request_any_context_irq(
                                  irq_ids[i],
                                  mymodule_irq_handler,
                                  IRQF_TRIGGER_HIGH,
                                  "mymodule_irq_handler",
                                  NULL
                                  );

That will select a hard-IRQ handler or a threaded IRQ handler, automatically for those IRQ requests that do not need both a hard and a threaded part.

[You can stop reading here if you want.]

―
1 If a "hard-IRQ" handler function is specified, it won't be called anyway because the threaded interrupt handler is going to be "nested" into the parent's threaded interrupt handler. The specified "hard-IRQ" handler will be replaced with irq_nested_primary_handler as shown in the code from __setup_irq above, but that replacement handler should not get called either. All it does is log a warning:

/*
 * Primary handler for nested threaded interrupts. Should never be
 * called.
 */
static irqreturn_t irq_nested_primary_handler(int irq, void *dev_id)
{
    WARN(1, "Primary handler called for nested irq %d\n", irq);
    return IRQ_NONE;
}

The interrupt controller is configured as a threaded interrupt controller in mcp23s08_probe_one in "drivers/pinctrl/pinctrl-mcp23s08.c":

    if (mcp->irq && mcp->irq_controller) {
        struct gpio_irq_chip *girq = &mcp->chip.irq;

        girq->chip = &mcp->irq_chip;
        /* This will let us handle the parent IRQ in the driver */
        girq->parent_handler = NULL;
        girq->num_parents = 0;
        girq->parents = NULL;
        girq->default_type = IRQ_TYPE_NONE;
        girq->handler = handle_simple_irq;
        girq->threaded = true;
    }

(girq->threaded = true; is the relevant line.)

Each child IRQ is mapped by gpiochip_irq_map in "drivers/gpio/gpiolib.c" and marked as using nested thread handlers:

    /* Chips that use nested thread handlers have them marked */
    if (gc->irq.threaded)
        irq_set_nested_thread(irq, 1);

The parent interrupt handler is itself set up as a threaded IRQ handler by mcp23s08_irq_setup in "drivers/pinctrl/pinctrl-mcp23s08.c":

static int mcp23s08_irq_setup(struct mcp23s08 *mcp)
{
    struct gpio_chip *chip = &mcp->chip;
    int err;
    unsigned long irqflags = IRQF_ONESHOT | IRQF_SHARED;

    if (mcp->irq_active_high)
        irqflags |= IRQF_TRIGGER_HIGH;
    else
        irqflags |= IRQF_TRIGGER_LOW;

    err = devm_request_threaded_irq(chip->parent, mcp->irq, NULL,
                    mcp23s08_irq,
                    irqflags, dev_name(chip->parent), mcp);
    if (err != 0) {
        dev_err(chip->parent, "unable to request IRQ#%d: %d\n",
            mcp->irq, err);
        return err;
    }

    return 0;
}

The parent interrupt handler mcp23s08_irq in "drivers/pinctrl/pinctrl-mcp23s08.c" calls handle_nested_irq to handle the child interrupt handlers:

            child_irq = irq_find_mapping(mcp->chip.irq.domain, i);
            handle_nested_irq(child_irq);

handle_nested_irq in "kernel/irq/chip.c" calls the child nested interrupt handler(s) for the child IRQ:

    for_each_action_of_desc(desc, action)
        action_ret |= action->thread_fn(action->irq, action->dev_id);
user_52644910
Related