Logic:

kernelthread fuer VME/CAMAC-IRQs und remote-IO und local-IO und sync-chngd 

Doorbell Interrupt (VME/CAMAC-IRQs + remote-IO)
    setzt sc->doorbell
    setzt handler_command|=handlercomm_doorbell
    weckt thread sofort

irq_lemo_in_chg (local-IO)
    setzt sc->doorbell ???
    setzt handler_command|=handlercomm_lemo
    weckt thread sofort

irq_synch_chg DOWN
    setzt sc->old_remote_hw=sc->remote_hw
    setzt sc->remote_hw=sis1100_hw_invalid
    setzt handler_command|=handlercomm_synch
    weckt thread sofort
    startet sis1100_synch_s_handler nach 1 s
        setzt sc->handlercommand.command|=handlercomm_synch
        weckt thread sofort

irq_synch_chg UP
    startet sis1100_synch_s_handler nach 1 s
        setzt sc->handlercommand.command|=handlercomm_synch
        weckt thread sofort


NetBSD

von sis1100_ioctl.c (in sis1100_vme_irq.c):
    sis1100_irq_ctl(sc, fd, d);
    sis1100_irq_get(sc, fd, d);
    sis1100_irq_ack(sc, fd, d);
    sis1100_irq_wait(sc, fd, d);


sis1100_irq_ctl:
    uses
        sc->fdatalist[idx]->owned_irqs (==fd->owned_irqs?)

sis1100_irq_ack:
    uses
        fd->owned_irqs
        sc->pending_irqs

sis1100_irq_get
    uses
        sc->pending_irqs
        fd->owned_irqs
        sc->irq_vects[bit].valid
        sc->irq_vects[bit].vector

sis1100_irq_wait
    uses
        fd->owned_irqs
        ltsleep(&sc->vmeirq_wait, PCATCH, "vmeirq", 0, &sc->vmeirq_wait);
        sc->irq_vects
        sc->pending_irqs
        simple_lock(&sc->vmeirq_wait);
        simple_unlock(&sc->vmeirq_wait);

Doorbell Interrupt:
    sc->doorbell|=plxreadreg(sc, L2PDBELL)
    wakeup_vmeirq=1;
    if (wakeup_vmeirq) wakeup(&sc->vmeirq_wait);

irq_synch_chg
    callout_reset(&sc->link_up_timer, hz, sis1100_synch_handler, sc);

in sis1100_init_remote (sis1100_init_remote.c):
    simple_lock(&sc->vmeirq_wait);
    sc->remote_hw=typ;
    simple_unlock(&sc->vmeirq_wait);

in sis1100_vme_irq_handler (in sis1100_vme_irq.c)
    simple_lock(&sc->vmeirq_wait);
    sc->pending_irqs|=new_irqs;
    simple_unlock(&sc->vmeirq_wait);
    ...
    wakeup(&sc->vmeirq_wait);


sis1100thread_vmeirq (in sis1100_vme_irq.c)
    while (1) {
        tsleep(&sc->vmeirq_pp, PCATCH, "thread_vmeirq", 0);
        command=sc->vmeirq_command.command;
        ...
        sis1100_vme_irq_handler(sc);
    }

Linux

von sis1100_ioctl.c (in ...):
    sis1100_irq_ctl(fd, &data);
    sis1100_irq_get(fd, &data);
    sis1100_irq_ack(fd, &data);
    sis1100_irq_wait(fd, &data);

Doorbell Interrupt:
        sc->doorbell|=help;
        handler_command|=handlercomm_doorbell;
        wakeup_remote=1;

irq_synch_chg
        sc->old_remote_hw=sc->remote_hw;
        sc->remote_hw=sis1100_hw_invalid;
        handler_command|=handlercomm_synch;
        wakeup_remote=1;
        mod_timer(&sc->link_up_timer, jiffies+HZ);

irq_lemo_in_chg
        /*sc->doorbell|=(status<<4)&0x30000;*/
        handler_command|=handlercomm_lemo;
        wakeup_remote=1;

        if (wakeup_remote) {
            spin_lock_irqsave(&sc->handlercommand.lock, flags);
            sc->handlercommand.command=handler_command;
            spin_unlock_irqrestore(&sc->handlercommand.lock, flags);
            wake_up(&sc->handler_wait);
        }


