Changeset 6cd9aa6 in mainline


Ignore:
Timestamp:
2009-02-15T23:13:55Z (16 years ago)
Author:
Jakub Jermar <jakub@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
17f168e
Parents:
fa09449
Message:

IRQ handlers are using one superfluous argument and an unused elipsis.
On the other hand, IRQ claim functions would need to be passed the instance
argument.

Location:
kernel
Files:
27 edited

Legend:

Unmodified
Added
Removed

  • kernel/arch/amd64/src/interrupt.c

    rfa09449 r6cd9aa6  
    174174                        ack = true;
    175175                }
    176                 irq->handler(irq, irq->arg);
     176                irq->handler(irq);
    177177                spinlock_unlock(&irq->lock);
    178178        } else {

  • kernel/arch/arm32/src/drivers/gxemul.c

    rfa09449 r6cd9aa6  
    185185 * 
    186186 *  @param irq IRQ information.
    187  *  @param arg Not used.
    188  */
    189 static void gxemul_irq_handler(irq_t *irq, void *arg, ...)
     187 */
     188static void gxemul_irq_handler(irq_t *irq)
    190189{
    191190        if ((irq->notif_cfg.notify) && (irq->notif_cfg.answerbox)) {
    … …  
    205204}
    206205
    207 static irq_ownership_t gxemul_claim(void)
     206static irq_ownership_t gxemul_claim(void *instance)
    208207{
    209208        return IRQ_ACCEPT;
    … …  
    267266}
    268267
    269 static irq_ownership_t gxemul_timer_claim(void)
     268static irq_ownership_t gxemul_timer_claim(void *instance)
    270269{
    271270        return IRQ_ACCEPT;
    … …  
    277276 * @param arg Not used.
    278277 */
    279 static void gxemul_timer_irq_handler(irq_t *irq, void *arg, ...)
     278static void gxemul_timer_irq_handler(irq_t *irq)
    280279{
    281280        /*
    … …  
    371370                        if (irq) {
    372371                                /* The IRQ handler was found. */
    373                                 irq->handler(irq, irq->arg);
     372                                irq->handler(irq);
    374373                                spinlock_unlock(&irq->lock);
    375374                        } else {

  • kernel/arch/ia32/src/drivers/i8254.c

    rfa09449 r6cd9aa6  
    6262static irq_t i8254_irq;
    6363
    64 static irq_ownership_t i8254_claim(void)
     64static irq_ownership_t i8254_claim(void *instance)
    6565{
    6666        return IRQ_ACCEPT;
    6767}
    6868
    69 static void i8254_irq_handler(irq_t *irq, void *arg __attribute__((unused)), ...)
     69static void i8254_irq_handler(irq_t *irq)
    7070{
    7171        /*

  • kernel/arch/ia32/src/interrupt.c

    rfa09449 r6cd9aa6  
    189189                        ack = true;
    190190                }
    191                 irq->handler(irq, irq->arg);
     191                irq->handler(irq);
    192192                spinlock_unlock(&irq->lock);
    193193        } else {

  • kernel/arch/ia32/src/smp/apic.c

    rfa09449 r6cd9aa6  
    133133}
    134134
    135 static irq_ownership_t l_apic_timer_claim(void)
     135static irq_ownership_t l_apic_timer_claim(void *instance)
    136136{
    137137        return IRQ_ACCEPT;
    138138}
    139139
    140 static void l_apic_timer_irq_handler(irq_t *irq, void *arg __attribute__((unused)), ...)
     140static void l_apic_timer_irq_handler(irq_t *irq)
    141141{
    142142        /*

  • kernel/arch/ia64/src/drivers/it.c

    rfa09449 r6cd9aa6  
    5757static irq_t it_irq;
    5858
    59 static irq_ownership_t it_claim(void);
    60 static void it_interrupt(irq_t *irq, void *arg, ...);
     59static irq_ownership_t it_claim(void *);
     60static void it_interrupt(irq_t *irq);
    6161
    6262/** Initialize Interval Timer. */
    … …  
    105105 * @return Always IRQ_ACCEPT.
    106106 */
    107 irq_ownership_t it_claim(void)
     107irq_ownership_t it_claim(void *instance)
    108108{
    109109        return IRQ_ACCEPT;
    … …  
    111111
    112112/** Process Interval Timer interrupt. */
    113 void it_interrupt(irq_t *irq, void *arg, ...)
     113void it_interrupt(irq_t *irq)
    114114{
    115115        int64_t c;

  • kernel/arch/ia64/src/interrupt.c

    rfa09449 r6cd9aa6  
    267267                irq = irq_dispatch_and_lock(ivr.vector);
    268268                if (irq) {
    269                         irq->handler(irq, irq->arg);
     269                        irq->handler(irq);
    270270                        spinlock_unlock(&irq->lock);
    271271                } else {
    … …  
    284284                                end_of_local_irq();
    285285                        }
    286                         irq->handler(irq, irq->arg);
     286                        irq->handler(irq);
    287287                        if (!irq->preack)
    288288                                end_of_local_irq();

  • kernel/arch/ia64/src/ski/ski.c

    rfa09449 r6cd9aa6  
    187187 * @return Always IRQ_DECLINE.
    188188 */
    189 static irq_ownership_t ski_kbd_claim(void)
     189static irq_ownership_t ski_kbd_claim(void *instance)
    190190{
    191191        return IRQ_DECLINE;

  • kernel/arch/mips32/src/drivers/msim.c

    rfa09449 r6cd9aa6  
    9595
    9696/** Process keyboard interrupt. */
    97 static void msim_irq_handler(irq_t *irq, void *arg, ...)
     97static void msim_irq_handler(irq_t *irq)
    9898{
    9999        if ((irq->notif_cfg.notify) && (irq->notif_cfg.answerbox))
    … …  
    111111}
    112112
    113 static irq_ownership_t msim_claim(void)
     113static irq_ownership_t msim_claim(void *instance)
    114114{
    115115        return IRQ_ACCEPT;

  • kernel/arch/mips32/src/drivers/serial.c

    rfa09449 r6cd9aa6  
    113113
    114114/** Process keyboard interrupt. Does not work in simics? */
    115 static void serial_irq_handler(irq_t *irq, void *arg, ...)
     115static void serial_irq_handler(irq_t *irq)
    116116{
    117117        if ((irq->notif_cfg.notify) && (irq->notif_cfg.answerbox))
    … …  
    121121}
    122122
    123 static irq_ownership_t serial_claim(void)
     123static irq_ownership_t serial_claim(void *instance)
    124124{
    125125        return IRQ_ACCEPT;

  • kernel/arch/mips32/src/exception.c

    rfa09449 r6cd9aa6  
    145145       
    146146        /* decode interrupt number and process the interrupt */
    147         cause = (cp0_cause_read() >> 8) &0xff;
     147        cause = (cp0_cause_read() >> 8) & 0xff;
    148148       
    149149        for (i = 0; i < 8; i++) {
    … …  
    154154                                 * The IRQ handler was found.
    155155                                 */
    156                                 irq->handler(irq, irq->arg);
     156                                irq->handler(irq);
    157157                                spinlock_unlock(&irq->lock);
    158158                        } else {
    … …  
    161161                                 */
    162162#ifdef CONFIG_DEBUG
    163                                 printf("cpu%u: spurious interrupt (inum=%d)\n", CPU->id, i);
     163                                printf("cpu%u: spurious interrupt (inum=%d)\n",
     164                                    CPU->id, i);
    164165#endif
    165166                        }

  • kernel/arch/mips32/src/interrupt.c

    rfa09449 r6cd9aa6  
    101101}
    102102
    103 static irq_ownership_t timer_claim(void)
     103static irq_ownership_t timer_claim(void *instance)
    104104{
    105105        return IRQ_ACCEPT;
    106106}
    107107
    108 static void timer_irq_handler(irq_t *irq, void *arg, ...)
     108static void timer_irq_handler(irq_t *irq)
    109109{
    110110        unsigned long drift;

  • kernel/arch/ppc32/src/drivers/cuda.c

    rfa09449 r6cd9aa6  
    250250}
    251251
    252 static void cuda_irq_handler(irq_t *irq, void *arg, ...)
     252static void cuda_irq_handler(irq_t *irq)
    253253{
    254254        if ((irq->notif_cfg.notify) && (irq->notif_cfg.answerbox))
    … …  
    265265}
    266266
    267 static irq_ownership_t cuda_claim(void)
     267static irq_ownership_t cuda_claim(void *instance)
    268268{
    269269        return IRQ_ACCEPT;

  • kernel/arch/ppc32/src/interrupt.c

    rfa09449 r6cd9aa6  
    7474                        }
    7575                       
    76                         irq->handler(irq, irq->arg);
     76                        irq->handler(irq);
    7777                        spinlock_unlock(&irq->lock);
    7878                } else {

  • kernel/arch/sparc64/include/cpu_family.h

    rfa09449 r6cd9aa6  
    8181/** @}
    8282 */
     83

  • kernel/arch/sparc64/include/cpu_node.h

    rfa09449 r6cd9aa6  
    5757/** @}
    5858 */
     59

  • kernel/arch/sparc64/src/drivers/sgcn.c

    rfa09449 r6cd9aa6  
    320320 * The driver works in polled mode, so no interrupt should be handled by it.
    321321 */
    322 static irq_ownership_t sgcn_claim(void)
     322static irq_ownership_t sgcn_claim(void *instance)
    323323{
    324324        return IRQ_DECLINE;
    … …  
    328328 * The driver works in polled mode, so no interrupt should be handled by it.
    329329 */
    330 static void sgcn_irq_handler(irq_t *irq, void *arg, ...)
     330static void sgcn_irq_handler(irq_t *irq)
    331331{
    332332        panic("Not yet implemented, SGCN works in polled mode.");

  • kernel/arch/sparc64/src/trap/interrupt.c

    rfa09449 r6cd9aa6  
    8787                 * The IRQ handler was found.
    8888                 */
    89                 irq->handler(irq, irq->arg);
     89                irq->handler(irq);
    9090                /*
    9191                 * See if there is a clear-interrupt-routine and call it.

  • kernel/genarch/include/kbd/ns16550.h

    rfa09449 r6cd9aa6  
    4747extern void ns16550_release(void);
    4848extern char ns16550_key_read(chardev_t *);
    49 extern irq_ownership_t ns16550_claim(void);
    50 extern void ns16550_irq_handler(irq_t *, void *, ...);
     49extern irq_ownership_t ns16550_claim(void *);
     50extern void ns16550_irq_handler(irq_t *);
    5151
    5252#include <arch/types.h>

  • kernel/genarch/include/kbd/z8530.h

    rfa09449 r6cd9aa6  
    5050extern void z8530_interrupt(void);
    5151extern char z8530_key_read(chardev_t *);
    52 extern irq_ownership_t z8530_claim(void);
    53 extern void z8530_irq_handler(irq_t *, void *, ...);
     52extern irq_ownership_t z8530_claim(void *);
     53extern void z8530_irq_handler(irq_t *);
    5454
    5555#endif

  • kernel/genarch/src/kbd/i8042.c

    rfa09449 r6cd9aa6  
    124124}
    125125
    126 static irq_ownership_t i8042_claim(void)
     126static irq_ownership_t i8042_claim(void *instance)
    127127{
    128128        return IRQ_ACCEPT;
    129129}
    130130
    131 static void i8042_irq_handler(irq_t *irq, void *arg, ...)
     131static void i8042_irq_handler(irq_t *irq)
    132132{
    133133        if (irq->notif_cfg.notify && irq->notif_cfg.answerbox)

  • kernel/genarch/src/kbd/ns16550.c

    rfa09449 r6cd9aa6  
    211211}
    212212
    213 irq_ownership_t ns16550_claim(void)
     213irq_ownership_t ns16550_claim(void *instance)
    214214{
    215215        return (ns16550_lsr_read(&ns16550) & LSR_DATA_READY);
    216216}
    217217
    218 void ns16550_irq_handler(irq_t *irq, void *arg, ...)
     218void ns16550_irq_handler(irq_t *irq)
    219219{
    220220        if (irq->notif_cfg.notify && irq->notif_cfg.answerbox)

  • kernel/genarch/src/kbd/z8530.c

    rfa09449 r6cd9aa6  
    195195}
    196196
    197 irq_ownership_t z8530_claim(void)
     197irq_ownership_t z8530_claim(void *instance)
    198198{
    199199        return (z8530_read_a(&z8530, RR0) & RR0_RCA);
    200200}
    201201
    202 void z8530_irq_handler(irq_t *irq, void *arg, ...)
     202void z8530_irq_handler(irq_t *irq)
    203203{
    204204        if (irq->notif_cfg.notify && irq->notif_cfg.answerbox)

  • kernel/generic/include/ddi/irq.h

    rfa09449 r6cd9aa6  
    8080
    8181struct irq;
    82 typedef void (* irq_handler_t)(struct irq *irq, void *arg, ...);
     82typedef void (* irq_handler_t)(struct irq *);
    8383
    8484/** Type for function used to clear the interrupt. */
    85 typedef void (* cir_t)(void *arg, inr_t inr);
     85typedef void (* cir_t)(void *, inr_t);
    8686
    8787/** IPC notification config structure.
    … …  
    140140        irq_trigger_t trigger;
    141141        /** Claim ownership of the IRQ. */
    142         irq_ownership_t (* claim)(void);
     142        irq_ownership_t (* claim)(void *);
    143143        /** Handler for this IRQ and device. */
    144144        irq_handler_t handler;
    145         /** Argument for the handler. */
    146         void *arg;
     145        /** Instance argument for the handler and the claim function. */
     146        void *instance;
    147147
    148148        /** Clear interrupt routine. */
    … …  
    155155} irq_t;
    156156
    157 extern void irq_init(count_t inrs, count_t chains);
    158 extern void irq_initialize(irq_t *irq);
    159 extern void irq_register(irq_t *irq);
    160 extern irq_t *irq_dispatch_and_lock(inr_t inr);
    161 extern irq_t *irq_find_and_lock(inr_t inr, devno_t devno);
     157extern void irq_init(count_t, count_t);
     158extern void irq_initialize(irq_t *);
     159extern void irq_register(irq_t *);
     160extern irq_t *irq_dispatch_and_lock(inr_t);
     161extern irq_t *irq_find_and_lock(inr_t, devno_t);
    162162
    163163#endif

  • kernel/generic/src/console/console.c

    rfa09449 r6cd9aa6  
    102102 * @return Always returns IRQ_DECLINE.
    103103 */
    104 static irq_ownership_t klog_claim(void)
     104static irq_ownership_t klog_claim(void *instance)
    105105{
    106106        return IRQ_DECLINE;

  • kernel/generic/src/console/kconsole.c

    rfa09449 r6cd9aa6  
    104104 *
    105105 */
    106 static irq_ownership_t kconsole_claim(void)
     106static irq_ownership_t kconsole_claim(void *instance)
    107107{
    108108        return IRQ_DECLINE;

  • kernel/generic/src/ddi/irq.c

    rfa09449 r6cd9aa6  
    4040 * This code is designed to support:
    4141 * - multiple devices sharing single IRQ
    42  * - multiple IRQs per signle device
     42 * - multiple IRQs per single device
     43 * - multiple instances of the same device
    4344 *
    4445 *
    … …  
    145146        irq->claim = NULL;
    146147        irq->handler = NULL;
    147         irq->arg = NULL;
     148        irq->instance = NULL;
    148149        irq->cir = NULL;
    149150        irq->cir_arg = NULL;
    … …  
    307308        if (devno == -1) {
    308309                /* Invoked by irq_dispatch_and_lock(). */
    309                 rv = ((irq->inr == inr) && (irq->claim() == IRQ_ACCEPT));
     310                rv = ((irq->inr == inr) &&
     311                    (irq->claim(irq->instance) == IRQ_ACCEPT));
    310312        } else {
    311313                /* Invoked by irq_find_and_lock(). */
    … …  
    366368        if (devno == -1) {
    367369                /* Invoked by irq_dispatch_and_lock() */
    368                 rv = (irq->claim() == IRQ_ACCEPT);
     370                rv = (irq->claim(irq->instance) == IRQ_ACCEPT);
    369371        } else {
    370372                /* Invoked by irq_find_and_lock() */
Note: See TracChangeset for help on using the changeset viewer.