STRUCT REGMAP_IRQ_CHIP(9)

💅 struct regmap_irq_chip(9) — the kernel API manual, bestie edition

okay so. this is struct regmap_irq_chip(9) from the Kernel API Manual, and it's literally the blueprint for a generic regmap irq_chip. think of it as the main-character struct that tells the regmap-IRQ machinery everything it needs to know about your interrupt controller. let's get into it 🎀

✨ SYNOPSIS ✨

struct regmap_irq_chip {
    const char *name;
    const char *domain_suffix;
    unsigned int main_status;
    unsigned int num_main_status_bits;
    const struct regmap_irq_sub_irq_map *sub_reg_offsets;
    int num_main_regs;
    unsigned int status_base;
    unsigned int mask_base;
    unsigned int unmask_base;
    unsigned int ack_base;
    unsigned int wake_base;
    const unsigned int *config_base;
    unsigned int irq_reg_stride;
    unsigned int init_ack_masked:1;
    unsigned int mask_unmask_non_inverted:1;
    unsigned int use_ack:1;
    unsigned int ack_invert:1;
    unsigned int clear_ack:1;
    unsigned int status_invert:1;
    unsigned int status_is_level:1;
    unsigned int wake_invert:1;
    unsigned int type_in_mask:1;
    unsigned int clear_on_unmask:1;
    unsigned int runtime_pm:1;
    unsigned int no_status:1;
    int num_regs;
    const struct regmap_irq *irqs;
    int num_irqs;
    int num_config_bases;
    int num_config_regs;
    int (*handle_pre_irq)(void *irq_drv_data);
    int (*handle_post_irq)(void *irq_drv_data);
    int (*handle_mask_sync)(int index, unsigned int mask_buf_def,
    unsigned int mask_buf, void *irq_drv_data);
    int (*set_type_config)(unsigned int **buf, unsigned int type, const
    struct regmap_irq *irq_data, int idx, void *irq_drv_data);
    unsigned int (*get_irq_reg)(struct regmap_irq_chip_data *data,
    unsigned int base, int index);
    int (*irq_reqres)(void *irq_drv_data, irq_hw_number_t hwirq);
    void (*irq_relres)(void *irq_drv_data, irq_hw_number_t hwirq);
    void *irq_drv_data;
 };

🦋 MEMBERS 🦋

name — the descriptive name for your IRQ controller. give it a cute one, it deserves it 💖
domain_suffix — a name suffix that gets appended to the end of the IRQ domain name. you need this when multiple regmap-IRQ controllers are created from the same device (iykyk, can't have two domains with the same name, that's giving chaos).
main_status — base main status register address. for chips that have interrupts arranged in separate sub-irq blocks with their own IRQ registers, plus a main IRQ register that flags which sub-irq blocks have unhandled interrupts. for those chips, you put the sub-irq register info in status_base, mask_base and ack_base.
num_main_status_bits — should be given to chips where the number of meaningfull main status bits differs from num_regs. (yes, "meaningfull", we keep it 💀)
sub_reg_offsets — arrays of mappings from main register bits to sub irq registers. the first item in the array describes the registers for the first main status bit, the second array for the second bit, etc. the offset is given as the sub register status offset to status_base. should contain num_regs arrays. can be provided for chips with a more complex mapping than "1.st bit to 1.st sub-reg, 2.nd bit to 2.nd sub-reg, ..." — you know the vibe.
num_main_regs — number of 'main status' irq registers, for chips that have main_status set.
status_base — base status register address. the moment ✨
mask_base — base mask register address. mask bits are set to 1 when an interrupt is masked, 0 when unmasked.
unmask_base — base unmask register address. unmask bits are set to 1 when an interrupt is unmasked and 0 when masked. iconique.
ack_base — base ack address. if zero, then the chip is clear on read. using a zero value is possible with the use_ack bit.
wake_base — base address for wake enables. if zero, unsupported 🙈
config_base — base address for IRQ type config regs. if null, unsupported.
irq_reg_stride — the stride to use for chips where registers are not contiguous.
init_ack_masked — ack all masked interrupts once during initalization.
mask_unmask_non_inverted — controls mask bit inversion for chips that set both mask_base and unmask_base. if false, mask and unmask bits are inverted (which is deprecated behavior 😬); if true, bits will not be inverted and the registers keep their normal behavior. note that if you use only one of mask_base or unmask_base, this flag has no effect and is unnecessary. any new drivers that set both mask_base and unmask_base should set this to true to avoid relying on the deprecated behavior. do it. don't be that driver 💅
use_ack — use the ack register even if it is zero.
ack_invert — inverted ack register: cleared bits for ack.
clear_ack — use this to set 1 and 0 or vice-versa to clear interrupts.
status_invert — inverted status register: cleared bits are active interrupts.
status_is_level — the status register is actuall signal level: xor the status register with the previous value to get the active interrupts.
wake_invert — inverted wake register: cleared bits are wake disabled.
type_in_mask — use the mask registers for controlling irq type. use this if the hardware provides separate bits for rising/falling edge or low/high level interrupts and they should be combined into a single logical interrupt. use struct regmap_irq_type data to define the mask bit for each irq type.
clear_on_unmask — for chips with interrupts cleared on read: read the status registers before unmasking interrupts, to clear any bits set when they were masked.
runtime_pm — hold a runtime PM lock on the device when accessing it. 🔒
no_status — no status register: all interrupts assumed generated by device.
num_regs — number of registers in each control bank.
irqs — descriptors for individual IRQs. interrupt numbers are assigned based on the index in the array of the interrupt.
num_irqs — number of descriptors.
num_config_bases — number of config base registers.
num_config_regs — number of config registers for each config base register.
handle_pre_irq — driver specific callback to handle an interrupt from the device before regmap_irq_handler processes the interrupts.
handle_post_irq — driver specific callback to handle an interrupt from the device after handling the interrupts in regmap_irq_handler. bestie bookends 🫶
handle_mask_sync — callback used to handle IRQ mask syncs. the index will be in the range [0, num_regs)
set_type_config — callback used for configuring irq types.
get_irq_reg — callback for mapping (base register, index) pairs to register addresses. the base register will be one of status_base, mask_base, etc., main_status, or any of config_base. the index will be in the range [0, num_main_regs[ for the main status base, [0, num_config_regs[ for any config register base, and [0, num_regs[ for any other base. if unspecified then regmap_irq_get_irq_reg_linear is used.
irq_reqres — callback function to request IRQ resources (may be NULL)
irq_relres — callback function to release IRQ resources (may be NULL)
irq_drv_data — driver specific IRQ data which is passed as parameter when the driver specific pre/post interrupt handler is called.

🌸 DESCRIPTION 🌸

so this whole thing is not intended to handle every possible interrupt controller — but it should handle a substantial proportion of those that are found in the wild. no cap, it's a solid generalist 🌈

⭐ SEE ALSO ⭐

that's the whole page, bestie, you ate it 💅 this one lives in ./include/linux and it's dated October 2026 — struct regmap_irq_chip(9), out 🫶✨

📦 where this page comes from

nixpkgs unstable: linux-manual 7.3.1
💖 girlified by deepseek-ai/DeepSeek-V4.1-Flash-1017 on 2026-11-04: a language model's rewrite of the original, under its terms