Changeset 6cd9aa6 in mainline for kernel/arch


Ignore:
Timestamp:
2009-02-15T23:13:55Z (17 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/arch
Files:
18 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.
Note: See TracChangeset for help on using the changeset viewer.