Changeset 8d2760f in mainline


Ignore:
Timestamp:
2008-11-29T20:24:47Z (15 years ago)
Author:
Jakub Jermar <jakub@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
57e76cb
Parents:
dfd77382
Message:

Add additional members to the irq_t structure so that an interrupt-driven driver
does not need to know how to clear the level interrupt. The z8530 was modified
in this way and is much more generic. The ns16550 driver has also been modified,
but awaits testing. The sparc64 interrupt mapping and dispatch code is now using
the new info and calls the clear-interrupt-routine itself.

Location:
kernel
Files:
16 edited

Legend:

Unmodified
Added
Removed
  • kernel/arch/sparc64/include/drivers/fhc.h

    rdfd77382 r8d2760f  
    4545extern fhc_t *central_fhc;
    4646
    47 extern fhc_t *fhc_init(ofw_tree_node_t *node);
    48 extern void fhc_enable_interrupt(fhc_t *fhc, int inr);
    49 extern void fhc_clear_interrupt(fhc_t *fhc, int inr);
     47extern fhc_t *fhc_init(ofw_tree_node_t *);
     48extern void fhc_enable_interrupt(fhc_t *, int);
     49extern void fhc_clear_interrupt(void *, int);
    5050
    5151#endif
  • kernel/arch/sparc64/include/drivers/pci.h

    rdfd77382 r8d2760f  
    5252
    5353struct pci_operations {
    54         void (* enable_interrupt)(pci_t *pci, int inr);
    55         void (* clear_interrupt)(pci_t *pci, int inr);
     54        void (* enable_interrupt)(pci_t *, int);
     55        void (* clear_interrupt)(pci_t *, int);
    5656};
    5757
     
    6262};
    6363
    64 extern pci_t *pci_init(ofw_tree_node_t *node);
    65 extern void pci_enable_interrupt(pci_t *pci, int inr);
    66 extern void pci_clear_interrupt(pci_t *pci, int inr);
     64extern pci_t *pci_init(ofw_tree_node_t *);
     65extern void pci_enable_interrupt(pci_t *, int);
     66extern void pci_clear_interrupt(void *, int);
    6767
    6868#endif
  • kernel/arch/sparc64/src/drivers/fhc.c

    rdfd77382 r8d2760f  
    102102}
    103103
    104 void fhc_clear_interrupt(fhc_t *fhc, int inr)
     104void fhc_clear_interrupt(void *fhcp, int inr)
    105105{
     106        fhc_t *fhc = (fhc_t *)fhcp;
    106107        ASSERT(fhc->uart_imap);
    107108
  • kernel/arch/sparc64/src/drivers/kbd.c

    rdfd77382 r8d2760f  
    6464        ofw_tree_property_t *prop;
    6565        const char *name;
     66        cir_t cir;
     67        void *cir_arg;
    6668       
    6769        name = ofw_tree_node_name(node);
     
    110112                }
    111113                if (!ofw_fhc_map_interrupt(node->parent,
    112                     ((ofw_fhc_reg_t *) prop->value), interrupts, &inr)) {
     114                    ((ofw_fhc_reg_t *) prop->value), interrupts, &inr, &cir,
     115                    &cir_arg)) {
    113116                        printf("Failed to determine keyboard interrupt.\n");
    114117                        return;
     
    124127                }
    125128                if (!ofw_ebus_map_interrupt(node->parent,
    126                     ((ofw_ebus_reg_t *) prop->value), interrupts, &inr)) {
     129                    ((ofw_ebus_reg_t *) prop->value), interrupts, &inr, &cir,
     130                    &cir_arg)) {
    127131                        printf("Failed to determine keyboard interrupt.\n");
    128132                        return;
     
    147151#ifdef CONFIG_Z8530
    148152        case KBD_Z8530:
    149                 z8530_init(devno, inr, vaddr);
     153                z8530_init(devno, vaddr, inr, cir, cir_arg);
    150154                break;
    151155#endif
    152156#ifdef CONFIG_NS16550
    153157        case KBD_NS16550:
    154                 ns16550_init(devno, inr, (ioport_t)vaddr);
     158                ns16550_init(devno, (ioport_t)vaddr, inr, cir, cir_arg);
    155159                break;
    156160#endif
  • kernel/arch/sparc64/src/drivers/pci.c

    rdfd77382 r8d2760f  
    5555#define OBIO_CIR(ino)   (OBIO_CIR_BASE + ((ino) & INO_MASK))
    5656
    57 static void obio_enable_interrupt(pci_t *pci, int inr);
    58 static void obio_clear_interrupt(pci_t *pci, int inr);
    59 
    60 static pci_t *pci_sabre_init(ofw_tree_node_t *node);
    61 static pci_t *pci_psycho_init(ofw_tree_node_t *node);
     57static void obio_enable_interrupt(pci_t *, int);
     58static void obio_clear_interrupt(pci_t *, int);
     59
     60static pci_t *pci_sabre_init(ofw_tree_node_t *);
     61static pci_t *pci_psycho_init(ofw_tree_node_t *);
    6262
    6363/** PCI operations for Sabre model. */
     
    209209}
    210210
    211 void pci_clear_interrupt(pci_t *pci, int inr)
    212 {
     211void pci_clear_interrupt(void *pcip, int inr)
     212{
     213        pci_t *pci = (pci_t *)pcip;
     214
    213215        ASSERT(pci->op && pci->op->clear_interrupt);
    214216        pci->op->clear_interrupt(pci, inr);
  • kernel/arch/sparc64/src/trap/interrupt.c

    rdfd77382 r8d2760f  
    8080                 */
    8181                irq->handler(irq, irq->arg);
     82                /*
     83                 * See if there is a clear-interrupt-routine and call it.
     84                 */
     85                if (irq->cir) {
     86                        irq->cir(irq->cir_arg, irq->inr);
     87                }
    8288                spinlock_unlock(&irq->lock);
    8389        } else if (data0 > config.base) {
     
    99105#ifdef CONFIG_DEBUG
    100106                printf("cpu%u: spurious interrupt (intrcv=%#" PRIx64
    101                         ", data0=%#" PRIx64 ")\n", CPU->id, intrcv, data0);
     107                    ", data0=%#" PRIx64 ")\n", CPU->id, intrcv, data0);
    102108#endif
    103109        }
  • kernel/genarch/include/kbd/ns16550.h

    rdfd77382 r8d2760f  
    3939
    4040#include <console/chardev.h>
     41#include <ddi/irq.h>
    4142#include <ipc/irq.h>
    4243
    43 extern void ns16550_init(devno_t devno, inr_t inr, uintptr_t vaddr);
     44extern void ns16550_init(devno_t, uintptr_t, inr_t, cir_t, void *);
    4445extern void ns16550_poll(void);
    4546extern void ns16550_grab(void);
    4647extern void ns16550_release(void);
    47 extern char ns16550_key_read(chardev_t *d);
     48extern char ns16550_key_read(chardev_t *);
    4849extern irq_ownership_t ns16550_claim(void);
    49 extern void ns16550_irq_handler(irq_t *irq, void *arg, ...);
     50extern void ns16550_irq_handler(irq_t *, void *, ...);
    5051
    5152#include <arch/types.h>
  • kernel/genarch/include/kbd/z8530.h

    rdfd77382 r8d2760f  
    4040#include <console/chardev.h>
    4141#include <ipc/irq.h>
     42#include <ddi/irq.h>
    4243
    4344extern bool z8530_belongs_to_kernel;
    4445
    45 extern void z8530_init(devno_t devno, inr_t inr, uintptr_t vaddr);
     46extern void z8530_init(devno_t, uintptr_t, inr_t, cir_t, void *);
    4647extern void z8530_poll(void);
    4748extern void z8530_grab(void);
    4849extern void z8530_release(void);
    4950extern void z8530_interrupt(void);
    50 extern char z8530_key_read(chardev_t *d);
     51extern char z8530_key_read(chardev_t *);
    5152extern irq_ownership_t z8530_claim(void);
    52 extern void z8530_irq_handler(irq_t *irq, void *arg, ...);
     53extern void z8530_irq_handler(irq_t *, void *, ...);
    5354
    5455#endif
  • kernel/genarch/include/ofw/ofw_tree.h

    rdfd77382 r8d2760f  
    3131
    3232#include <arch/types.h>
     33#include <ddi/irq.h>
    3334#include <typedefs.h>
    3435
     
    4445        ofw_tree_node_t *child;
    4546
    46         uint32_t node_handle;                   /**< Old OpenFirmware node handle. */
    47 
    48         char *da_name;                          /**< Disambigued name. */
    49 
    50         unsigned properties;                    /**< Number of properties. */
     47        uint32_t node_handle;           /**< Old OpenFirmware node handle. */
     48
     49        char *da_name;                  /**< Disambigued name. */
     50
     51        unsigned properties;            /**< Number of properties. */
    5152        ofw_tree_property_t *property;
    5253       
     
    106107        uint32_t child_base;
    107108        uint32_t parent_space;
    108         uint64_t parent_base;           /* group phys.mid and phys.lo together */
     109        uint64_t parent_base;   /* group phys.mid and phys.lo together */
    109110        uint32_t size;
    110111} __attribute__ ((packed));
     
    128129
    129130struct ofw_pci_reg {
    130         uint32_t space;                 /* needs to be masked to obtain pure space id */
    131         uint64_t addr;                  /* group phys.mid and phys.lo together */
     131        uint32_t space;         /* needs to be masked to obtain pure space id */
     132        uint64_t addr;          /* group phys.mid and phys.lo together */
    132133        uint64_t size;
    133134} __attribute__ ((packed));
     
    136137struct ofw_pci_range {
    137138        uint32_t space;
    138         uint64_t child_base;            /* group phys.mid and phys.lo together */
     139        uint64_t child_base;    /* group phys.mid and phys.lo together */
    139140        uint64_t parent_base;
    140141        uint64_t size;
     
    161162typedef struct ofw_upa_reg ofw_upa_reg_t;
    162163
    163 extern void ofw_tree_init(ofw_tree_node_t *root);
     164extern void ofw_tree_init(ofw_tree_node_t *);
    164165extern void ofw_tree_print(void);
    165 extern const char *ofw_tree_node_name(const ofw_tree_node_t *node);
    166 extern ofw_tree_node_t *ofw_tree_lookup(const char *path);
    167 extern ofw_tree_property_t *ofw_tree_getprop(const ofw_tree_node_t *node, const char *name);
    168 extern ofw_tree_node_t *ofw_tree_find_child(ofw_tree_node_t *node, const char *name);
    169 extern ofw_tree_node_t *ofw_tree_find_child_by_device_type(ofw_tree_node_t *node, const char *device_type);
    170 extern ofw_tree_node_t *ofw_tree_find_peer_by_device_type(ofw_tree_node_t *node, const char *device_type);
    171 extern ofw_tree_node_t *ofw_tree_find_node_by_handle(ofw_tree_node_t *root, uint32_t handle);
    172 
    173 extern bool ofw_fhc_apply_ranges(ofw_tree_node_t *node, ofw_fhc_reg_t *reg, uintptr_t *pa);
    174 extern bool ofw_central_apply_ranges(ofw_tree_node_t *node, ofw_central_reg_t *reg, uintptr_t *pa);
    175 extern bool ofw_ebus_apply_ranges(ofw_tree_node_t *node, ofw_ebus_reg_t *reg, uintptr_t *pa);
    176 extern bool ofw_pci_apply_ranges(ofw_tree_node_t *node, ofw_pci_reg_t *reg, uintptr_t *pa);
    177 extern bool ofw_sbus_apply_ranges(ofw_tree_node_t *node, ofw_sbus_reg_t *reg, uintptr_t *pa);
    178 extern bool ofw_upa_apply_ranges(ofw_tree_node_t *node, ofw_upa_reg_t *reg, uintptr_t *pa);
    179 
    180 extern bool ofw_pci_reg_absolutize(ofw_tree_node_t *node, ofw_pci_reg_t *reg, ofw_pci_reg_t *out);
    181 
    182 extern bool ofw_fhc_map_interrupt(ofw_tree_node_t *node, ofw_fhc_reg_t *reg, uint32_t interrupt, int *inr);
    183 extern bool ofw_ebus_map_interrupt(ofw_tree_node_t *node, ofw_ebus_reg_t *reg, uint32_t interrupt, int *inr);
    184 extern bool ofw_pci_map_interrupt(ofw_tree_node_t *node, ofw_pci_reg_t *reg, int ino, int *inr);
     166extern const char *ofw_tree_node_name(const ofw_tree_node_t *);
     167extern ofw_tree_node_t *ofw_tree_lookup(const char *);
     168extern ofw_tree_property_t *ofw_tree_getprop(const ofw_tree_node_t *,
     169    const char *);
     170extern ofw_tree_node_t *ofw_tree_find_child(ofw_tree_node_t *, const char *);
     171extern ofw_tree_node_t *ofw_tree_find_child_by_device_type(ofw_tree_node_t *,
     172    const char *);
     173extern ofw_tree_node_t *ofw_tree_find_peer_by_device_type(ofw_tree_node_t *,
     174    const char *);
     175extern ofw_tree_node_t *ofw_tree_find_node_by_handle(ofw_tree_node_t *,
     176    uint32_t);
     177
     178extern bool ofw_fhc_apply_ranges(ofw_tree_node_t *, ofw_fhc_reg_t *,
     179    uintptr_t *);
     180extern bool ofw_central_apply_ranges(ofw_tree_node_t *, ofw_central_reg_t *,
     181    uintptr_t *);
     182extern bool ofw_ebus_apply_ranges(ofw_tree_node_t *, ofw_ebus_reg_t *,
     183    uintptr_t *);
     184extern bool ofw_pci_apply_ranges(ofw_tree_node_t *, ofw_pci_reg_t *,
     185    uintptr_t *);
     186extern bool ofw_sbus_apply_ranges(ofw_tree_node_t *, ofw_sbus_reg_t *,
     187    uintptr_t *);
     188extern bool ofw_upa_apply_ranges(ofw_tree_node_t *, ofw_upa_reg_t *,
     189    uintptr_t *);
     190
     191extern bool ofw_pci_reg_absolutize(ofw_tree_node_t *, ofw_pci_reg_t *,
     192    ofw_pci_reg_t *);
     193
     194extern bool ofw_fhc_map_interrupt(ofw_tree_node_t *, ofw_fhc_reg_t *,
     195    uint32_t, int *, cir_t *, void **);
     196extern bool ofw_ebus_map_interrupt(ofw_tree_node_t *, ofw_ebus_reg_t *,
     197    uint32_t, int *, cir_t *, void **);
     198extern bool ofw_pci_map_interrupt(ofw_tree_node_t *, ofw_pci_reg_t *,
     199    int, int *, cir_t *, void **);
    185200
    186201#endif
  • kernel/genarch/src/kbd/ns16550.c

    rdfd77382 r8d2760f  
    108108/** Initialize ns16550.
    109109 *
    110  * @param devno Device number.
    111  * @param inr Interrupt number.
    112  * @param vaddr Virtual address of device's registers.
    113  */
    114 void ns16550_init(devno_t devno, inr_t inr, ioport_t port)
     110 * @param devno         Device number.
     111 * @param port          Virtual/IO address of device's registers.
     112 * @param inr           Interrupt number.
     113 * @param cir           Clear interrupt function.
     114 * @param cir_arg       First argument to cir.
     115 */
     116void
     117ns16550_init(devno_t devno, ioport_t port, inr_t inr, cir_t cir, void *cir_arg)
    115118{
    116119        chardev_initialize("ns16550_kbd", &kbrd, &ops);
     
    125128        ns16550_irq.claim = ns16550_claim;
    126129        ns16550_irq.handler = ns16550_irq_handler;
     130        ns16550_irq.cir = cir;
     131        ns16550_irq.cir_arg = cir_arg;
    127132        irq_register(&ns16550_irq);
    128133       
  • kernel/genarch/src/kbd/z8530.c

    rdfd77382 r8d2760f  
    4444#include <arch/interrupt.h>
    4545#include <arch/drivers/kbd.h>
    46 #include <arch/drivers/fhc.h>
    4746#include <cpu.h>
    4847#include <arch/asm.h>
     
    8483        z8530_write_a(&z8530, WR0, WR0_TX_IP_RST);
    8584
    86         z8530_write_a(&z8530, WR1, WR1_IARCSC);         /* interrupt on all characters */
     85        /* interrupt on all characters */
     86        z8530_write_a(&z8530, WR1, WR1_IARCSC);
    8787
    8888        /* 8 bits per character and enable receiver */
    8989        z8530_write_a(&z8530, WR3, WR3_RX8BITSCH | WR3_RX_ENABLE);
    9090       
    91         z8530_write_a(&z8530, WR9, WR9_MIE);            /* Master Interrupt Enable. */
     91        /* Master Interrupt Enable. */
     92        z8530_write_a(&z8530, WR9, WR9_MIE);
    9293       
    9394        spinlock_lock(&z8530_irq.lock);
     
    109110
    110111/** Initialize z8530. */
    111 void z8530_init(devno_t devno, inr_t inr, uintptr_t vaddr)
     112void
     113z8530_init(devno_t devno, uintptr_t vaddr, inr_t inr, cir_t cir, void *cir_arg)
    112114{
    113115        chardev_initialize("z8530_kbd", &kbrd, &ops);
     
    122124        z8530_irq.claim = z8530_claim;
    123125        z8530_irq.handler = z8530_irq_handler;
     126        z8530_irq.cir = cir;
     127        z8530_irq.cir_arg = cir_arg;
    124128        irq_register(&z8530_irq);
    125129
     
    198202void z8530_irq_handler(irq_t *irq, void *arg, ...)
    199203{
    200         /*
    201          * So far, we know we got this interrupt through the FHC.
    202          * Since we don't have enough documentation about the FHC
    203          * and because the interrupt looks like level sensitive,
    204          * we cannot handle it by scheduling one of the level
    205          * interrupt traps. Process the interrupt directly.
    206          */
    207204        if (irq->notif_cfg.notify && irq->notif_cfg.answerbox)
    208205                ipc_irq_send_notif(irq);
    209206        else
    210207                z8530_interrupt();
    211         fhc_clear_interrupt(central_fhc, irq->inr);
    212208}
    213209
  • kernel/genarch/src/ofw/ebus.c

    rdfd77382 r8d2760f  
    4545
    4646/** Apply EBUS ranges to EBUS register. */
    47 bool ofw_ebus_apply_ranges(ofw_tree_node_t *node, ofw_ebus_reg_t *reg, uintptr_t *pa)
     47bool
     48ofw_ebus_apply_ranges(ofw_tree_node_t *node, ofw_ebus_reg_t *reg, uintptr_t *pa)
    4849{
    4950        ofw_tree_property_t *prop;
     
    6364                if (reg->space != range[i].child_space)
    6465                        continue;
    65                 if (overlaps(reg->addr, reg->size, range[i].child_base, range[i].size)) {
     66                if (overlaps(reg->addr, reg->size, range[i].child_base,
     67                    range[i].size)) {
    6668                        ofw_pci_reg_t pci_reg;
    6769                       
    6870                        pci_reg.space = range[i].parent_space;
    69                         pci_reg.addr = range[i].parent_base + (reg->addr - range[i].child_base);
     71                        pci_reg.addr = range[i].parent_base +
     72                            (reg->addr - range[i].child_base);
    7073                        pci_reg.size = reg->size;
    7174                       
     
    7780}
    7881
    79 bool ofw_ebus_map_interrupt(ofw_tree_node_t *node, ofw_ebus_reg_t *reg, uint32_t interrupt, int *inr)
     82bool
     83ofw_ebus_map_interrupt(ofw_tree_node_t *node, ofw_ebus_reg_t *reg,
     84    uint32_t interrupt, int *inr, cir_t *cir, void **cir_arg)
    8085{
    8186        ofw_tree_property_t *prop;
     
    105110        unsigned int i;
    106111        for (i = 0; i < count; i++) {
    107                 if ((intr_map[i].space == space) && (intr_map[i].addr == addr)
    108                         && (intr_map[i].intr == intr))
     112                if ((intr_map[i].space == space) &&
     113                    (intr_map[i].addr == addr) && (intr_map[i].intr == intr))
    109114                        goto found;
    110115        }
     
    114119        /*
    115120         * We found the device that functions as an interrupt controller
    116          * for the interrupt. We also found partial mapping from interrupt to INO.
     121         * for the interrupt. We also found partial mapping from interrupt to
     122         * INO.
    117123         */
    118124
    119         controller = ofw_tree_find_node_by_handle(ofw_tree_lookup("/"), intr_map[i].controller_handle);
     125        controller = ofw_tree_find_node_by_handle(ofw_tree_lookup("/"),
     126            intr_map[i].controller_handle);
    120127        if (!controller)
    121128                return false;
     
    131138         * Let the PCI do the next step in mapping the interrupt.
    132139         */
    133         if (!ofw_pci_map_interrupt(controller, NULL, intr_map[i].controller_ino, inr))
     140        if (!ofw_pci_map_interrupt(controller, NULL, intr_map[i].controller_ino,
     141            inr, cir, cir_arg))
    134142                return false;
    135143
  • kernel/genarch/src/ofw/fhc.c

    rdfd77382 r8d2760f  
    110110}
    111111
    112 bool ofw_fhc_map_interrupt(ofw_tree_node_t *node, ofw_fhc_reg_t *reg, uint32_t interrupt, int *inr)
     112bool
     113ofw_fhc_map_interrupt(ofw_tree_node_t *node, ofw_fhc_reg_t *reg,
     114    uint32_t interrupt, int *inr, cir_t *cir, void **cir_arg)
    113115{
    114116        fhc_t *fhc = NULL;
     
    127129       
    128130        *inr = interrupt;
     131        *cir = fhc_clear_interrupt;
     132        *cir_arg = fhc;
    129133        return true;
    130134}
  • kernel/genarch/src/ofw/pci.c

    rdfd77382 r8d2760f  
    5050#define PCI_IGN                 0x1f
    5151
    52 bool ofw_pci_apply_ranges(ofw_tree_node_t *node, ofw_pci_reg_t *reg, uintptr_t *pa)
     52bool
     53ofw_pci_apply_ranges(ofw_tree_node_t *node, ofw_pci_reg_t *reg, uintptr_t *pa)
    5354{
    5455        ofw_tree_property_t *prop;
     
    6970       
    7071        for (i = 0; i < ranges; i++) {
    71                 if ((reg->space & PCI_SPACE_MASK) != (range[i].space & PCI_SPACE_MASK))
     72                if ((reg->space & PCI_SPACE_MASK) !=
     73                    (range[i].space & PCI_SPACE_MASK))
    7274                        continue;
    73                 if (overlaps(reg->addr, reg->size, range[i].child_base, range[i].size)) {
    74                         *pa = range[i].parent_base + (reg->addr - range[i].child_base);
     75                if (overlaps(reg->addr, reg->size, range[i].child_base,
     76                    range[i].size)) {
     77                        *pa = range[i].parent_base +
     78                            (reg->addr - range[i].child_base);
    7579                        return true;
    7680                }
     
    8084}
    8185
    82 bool ofw_pci_reg_absolutize(ofw_tree_node_t *node, ofw_pci_reg_t *reg, ofw_pci_reg_t *out)
     86bool
     87ofw_pci_reg_absolutize(ofw_tree_node_t *node, ofw_pci_reg_t *reg,
     88    ofw_pci_reg_t *out)
    8389{
    8490        if (reg->space & PCI_ABS_MASK) {
     
    104110       
    105111        for (i = 0; i < assigned_addresses; i++) {
    106                 if ((assigned_address[i].space & PCI_REG_MASK) == (reg->space & PCI_REG_MASK)) {
     112                if ((assigned_address[i].space & PCI_REG_MASK) ==
     113                    (reg->space & PCI_REG_MASK)) {
    107114                        out->space = assigned_address[i].space;
    108115                        out->addr = reg->addr + assigned_address[i].addr;
     
    120127 * to a PCI bridge.
    121128 */
    122 bool ofw_pci_map_interrupt(ofw_tree_node_t *node, ofw_pci_reg_t *reg, int ino, int *inr)
     129bool
     130ofw_pci_map_interrupt(ofw_tree_node_t *node, ofw_pci_reg_t *reg, int ino,
     131    int *inr, cir_t *cir, void **cir_arg)
    123132{
    124133        pci_t *pci = node->device;
     
    133142
    134143        *inr = (PCI_IGN << IGN_SHIFT) | ino;
     144        *cir = pci_clear_interrupt;
     145        *cir_arg = pci;
    135146
    136147        return true;
  • kernel/generic/include/ddi/irq.h

    rdfd77382 r8d2760f  
    8484typedef void (* irq_handler_t)(struct irq *irq, void *arg, ...);
    8585
     86/** Type for function used to clear the interrupt. */
     87typedef void (* cir_t)(void *arg, inr_t inr);
     88
    8689/** IPC notification config structure.
    8790 *
     
    145148        void *arg;
    146149
     150        /** Clear interrupt routine. */
     151        cir_t cir;
     152        /** First argument to the clear interrupt routine. */
     153        void *cir_arg;
     154
    147155        /** Notification configuration structure. */
    148156        ipc_notif_cfg_t notif_cfg;
  • kernel/generic/src/ddi/irq.c

    rdfd77382 r8d2760f  
    146146        irq->handler = NULL;
    147147        irq->arg = NULL;
     148        irq->cir = NULL;
     149        irq->cir_arg = NULL;
    148150        irq->notif_cfg.notify = false;
    149151        irq->notif_cfg.answerbox = NULL;
Note: See TracChangeset for help on using the changeset viewer.