source: soft/giet_vm/sys/irq_handler.c @ 228

///////////////////////////////////////////////////////////////////////////////////
// File     : irq_handler.c
// Date     : 01/04/2012
// Author   : alain greiner 
// Copyright (c) UPMC-LIP6
///////////////////////////////////////////////////////////////////////////////////
// The irq_handler.c and irq_handler.h files are part of the GIET-VM nano-kernel.
// They contain the code of the _irq_demux() function that access the XICU or
// ICU component (Interupt Controler Unit), and the various ISRs (Interrupt
// Service Routine) associated to the peripherals. 
///////////////////////////////////////////////////////////////////////////////////

#include <giet_config.h>
#include <irq_handler.h>
#include <sys_handler.h>
#include <drivers.h>
#include <common.h>
#include <ctx_handler.h>
#include <hwr_mapping.h>

#if NB_TIMERS_MAX
extern volatile unsigned char _user_timer_event[NB_CLUSTERS * NB_TIMERS_MAX] ;
#endif

///////////////////////////////////////////////////////////////////////////////////
//     _irq_demux()
// This function uses the ICU or XICU component (Interrupt Controler Unit)
// to get the interrupt vector entry. There is one ICU or XICU component per
// cluster, and this component can support up to NB_PROCS_MAX output IRQs.
// It returns the highest priority active interrupt index (smaller
// indexes have the highest priority).
// Any value larger than 31 means "no active interrupt", and no ISR is executed.
//
// There is one interrupt vector per processor (stored in the scheduler associated
// to the processor. Each interrupt vector entry contains two 16 bits fields:
// - isr_id : defines the type of ISR to be executed.
// - channel_id : defines the specific channel for multi-channels peripherals.
//
// If the peripheral is replicated in clusters (TIMER or DMA), the channel_id is 
// a global index : channel_id = cluster_id * NB_CHANNELS_MAX + loc_id   
///////////////////////////////////////////////////////////////////////////////////
void _irq_demux() {
    unsigned int pid = _procid();
    unsigned int irq_id;


    // get the highest priority active IRQ index 
    if (_icu_get_index( pid / NB_PROCS_MAX, pid % NB_PROCS_MAX, &irq_id)) {
        _get_lock(&_tty_put_lock);
        _puts("\n[GIET ERROR] Strange... Wrong _icu_read in _irq_demux()\n");
        _release_lock(&_tty_put_lock);
    }


    if (irq_id < 32) {
        // do nothing if no interrupt active 
        unsigned int entry = _get_interrupt_vector_entry(irq_id);
        unsigned int isr_id = entry & 0x000000FF;
        unsigned int channel_id = (entry >> 16) & 0x0000FFFF;
        if      ( isr_id == ISR_SWITCH) _isr_switch( channel_id);
        else if ( isr_id == ISR_IOC   ) _isr_ioc();
        else if ( isr_id == ISR_DMA   ) _isr_dma(channel_id);
        else if ( isr_id == ISR_TTY   ) _isr_tty(channel_id);
        else if ( isr_id == ISR_TIMER ) _isr_timer(channel_id);
        else                            _isr_default();
    }
}


///////////////////////////////////////////////////////////////////////////////////
//     _isr_default()
// The default ISR is called when no specific ISR has been installed in the
// interrupt vector. It simply displays an error message on kernel TTY[0].
///////////////////////////////////////////////////////////////////////////////////
void _isr_default() {
    _get_lock(&_tty_put_lock);
    _puts("\n[GIET ERROR] Strange... Default ISR activated for processor ");
    _putd( _procid() );
    _puts("\n");
    _release_lock(&_tty_put_lock);
}


///////////////////////////////////////////////////////////////////////////////////
//     _isr_dma()
// This ISR handles all IRQs generated by the multi-channels DMA controlers.
// The multi_dma components can be distributed in the clusters.
// The channel_id argument is the local DMA channel index.
//     dma_global_id = cluster_id*NB_DMAS_MAX + channel_id
// - The ISR saves the transfert status in _dma_status[dma_global_id].
// - It acknowledges the interrupt to reinitialize the DMA controler.
// - it resets the synchronisation variable _dma_busy[dma_global_id].
///////////////////////////////////////////////////////////////////////////////////
void _isr_dma(unsigned int channel_id) {
#if NB_DMAS_MAX > 0
    // compute cluster_id 
    unsigned int cluster_id = _procid() / NB_PROCS_MAX;

    // compute dma_global_id
    unsigned int dma_global_id = cluster_id * NB_DMAS_MAX + channel_id;

    // save DMA channel status  
    if (_dma_get_status(cluster_id, channel_id, 
            (unsigned int *) &_dma_status[dma_global_id])) {
        _get_lock(&_tty_put_lock);
        _puts("[GIET ERROR] illegal DMA channel detected by _isr_dma\n");
        _release_lock(&_tty_put_lock);
        return;
    }

    // reset DMA channel irq
    if (_dma_reset_irq(cluster_id, channel_id)) {
        _get_lock(&_tty_put_lock);
        _puts("[GIET ERROR] illegal DMA channel detected by _isr_dma\n");
        _release_lock(&_tty_put_lock);
        return;
    }

    // release DMA channel 
    _dma_done[dma_global_id] = 1;  
#else
    _puts("[GIET ERROR] NB_DMAS_MAX is set to zero\n");

#endif
}

///////////////////////////////////////////////////////////////////////////////////
//     _isr_ioc()
// There is only one IOC controler shared by all tasks. 
// - The ISR save the status and acknowledge the IRQ.
// - It sets the _ioc_done variable to signal completion.
///////////////////////////////////////////////////////////////////////////////////
void _isr_ioc() {
    // save status & reset IRQ 
    if (_ioc_get_status((unsigned int *) &_ioc_status )) {
        _get_lock(&_tty_put_lock);
        _puts("[GIET ERROR] bad access to IOC status detected by _isr_ioc\n");
        _release_lock(&_tty_put_lock);
        return;
    }

    // signals completion 
    _ioc_done = 1; 
}


///////////////////////////////////////////////////////////////////////////////////
//        _isr_timer()
// This ISR handles the IRQs generated by the "user" timers (the IRQs generated
// by the "system" timers should be handled by the _isr_switch().
// These timers are distributed in all clusters, and can be implemented
// in a vci_multi_timer component, or in a vci_xicu component.
// The timer_id argument is the user timer local index.
//     timer_globa_id = cluster_id*(NB_TIMERS_MAX) + timer_id 
// The ISR acknowledges the IRQ and registers the event in the proper entry
// of the _timer_event[] array, and a log message is displayed on kernel terminal.
///////////////////////////////////////////////////////////////////////////////////
void _isr_timer(unsigned int timer_id) {
    // compute cluster_id 
    unsigned int cluster_id = _procid() / NB_PROCS_MAX;

    // aknowledge IRQ 
    if (_timer_reset_irq( cluster_id, timer_id)) {
        _get_lock(&_tty_put_lock);
        _puts("[GIET ERROR] illegal timer index detected by _isr_timer\n");
        _release_lock(&_tty_put_lock);
        return;
    }

#if NB_TIMERS_MAX
    // register the event
    unsigned int timer_global_id = cluster_id * NB_TIMERS_MAX + timer_id;
    _user_timer_event[timer_global_id] = 1;
#endif

    // display a message on TTY 0 
    _get_lock(&_tty_put_lock);
    _puts("\n[GIET] User Timer IRQ at cycle ");
    _putd(_proctime());
    _puts("\n - cluster_id = ");
    _putd(cluster_id);
    _puts("\n - timer_id   = ");
    _putd(timer_id);
    _puts("\n");
    _release_lock(&_tty_put_lock);
}


///////////////////////////////////////////////////////////////////////////////////
//  _isr_tty()
// This ISR handles the IRQs generated by the multi_tty controler,
// signaling that a character is available.
// There is one single multi_tty component controling all TTYs, 
// and the tty_id argument is the global TTY index.
// There is one communication buffer _tty_buf[tty_id] per terminal.
// The sychronisation variable _tty_full[tty_id], is set by the ISR,
// and reset by the OS.
// A character is lost if the buffer is full when the ISR is executed.
///////////////////////////////////////////////////////////////////////////////////
void _isr_tty(unsigned int tty_id) {
    // save character and reset IRQ 
    if (_tty_get_char( tty_id, (unsigned char *) &_tty_get_buf[tty_id])) {
        _get_lock(&_tty_put_lock);
        _puts("[GIET ERROR] illegal tty index detected by _isr_tty\n");
        _release_lock(&_tty_put_lock);
        return;
    }

    // signals character available 
    _tty_get_full[tty_id] = 1;
}


/////////////////////////////////////////////////////////////////////////////////////
// _isr_switch
// This ISR is in charge of context switch, and handle the IRQs generated by
// the "system" timers. 
// The IRQs can be generated by the MULTI_TIMER component or by the XICU component,
// that are distributed in all clusters.
// The ISR acknowledges the IRQ and calls the _ctx_switch() function.
/////////////////////////////////////////////////////////////////////////////////////
void _isr_switch( unsigned int timer_id) {
    // get cluster index and proc local index
    unsigned int cluster_id = _procid() / NB_PROCS_MAX;

    // acknowledge IRQ
    if (_timer_reset_irq(cluster_id, timer_id)) {
        _get_lock(&_tty_put_lock);
        _puts("[GIET ERROR] illegal proc index detected by _isr_switch\n");
        _release_lock(&_tty_put_lock);
        return;
    }

    // performs the context switch
    _ctx_switch();
}


// Local Variables:
// tab-width: 4
// c-basic-offset: 4
// c-file-offsets:((innamespace . 0)(inline-open . 0))
// indent-tabs-mode: nil
// End:
// vim: filetype=c:expandtab:shiftwidth=4:tabstop=4:softtabstop=4