[158] | 1 | /////////////////////////////////////////////////////////////////////////////////// |
---|
| 2 | // File : irq_handler.c |
---|
| 3 | // Date : 01/04/2012 |
---|
[189] | 4 | // Author : alain greiner |
---|
[158] | 5 | // Copyright (c) UPMC-LIP6 |
---|
| 6 | /////////////////////////////////////////////////////////////////////////////////// |
---|
[189] | 7 | // The irq_handler.c and irq_handler.h files are part of the GIET-VM nano-kernel. |
---|
| 8 | // They contain the code of the _irq_demux() function that access the XICU or |
---|
| 9 | // ICU component (Interupt Controler Unit), and the various ISRs (Interrupt |
---|
| 10 | // Service Routine) associated to the peripherals. |
---|
[158] | 11 | /////////////////////////////////////////////////////////////////////////////////// |
---|
| 12 | |
---|
| 13 | #include <giet_config.h> |
---|
| 14 | #include <irq_handler.h> |
---|
| 15 | #include <sys_handler.h> |
---|
| 16 | #include <drivers.h> |
---|
| 17 | #include <common.h> |
---|
| 18 | #include <ctx_handler.h> |
---|
| 19 | #include <hwr_mapping.h> |
---|
| 20 | |
---|
[215] | 21 | #if NB_TIMERS_MAX |
---|
[228] | 22 | extern volatile unsigned char _user_timer_event[NB_CLUSTERS * NB_TIMERS_MAX] ; |
---|
[215] | 23 | #endif |
---|
| 24 | |
---|
[158] | 25 | /////////////////////////////////////////////////////////////////////////////////// |
---|
[228] | 26 | // _irq_demux() |
---|
[189] | 27 | // This function uses the ICU or XICU component (Interrupt Controler Unit) |
---|
| 28 | // to get the interrupt vector entry. There is one ICU or XICU component per |
---|
| 29 | // cluster, and this component can support up to NB_PROCS_MAX output IRQs. |
---|
| 30 | // It returns the highest priority active interrupt index (smaller |
---|
| 31 | // indexes have the highest priority). |
---|
| 32 | // Any value larger than 31 means "no active interrupt", and no ISR is executed. |
---|
[158] | 33 | // |
---|
[189] | 34 | // There is one interrupt vector per processor (stored in the scheduler associated |
---|
| 35 | // to the processor. Each interrupt vector entry contains two 16 bits fields: |
---|
| 36 | // - isr_id : defines the type of ISR to be executed. |
---|
| 37 | // - channel_id : defines the specific channel for multi-channels peripherals. |
---|
[158] | 38 | // |
---|
[189] | 39 | // If the peripheral is replicated in clusters (TIMER or DMA), the channel_id is |
---|
| 40 | // a global index : channel_id = cluster_id * NB_CHANNELS_MAX + loc_id |
---|
[158] | 41 | /////////////////////////////////////////////////////////////////////////////////// |
---|
[228] | 42 | void _irq_demux() { |
---|
| 43 | unsigned int pid = _procid(); |
---|
| 44 | unsigned int irq_id; |
---|
[158] | 45 | |
---|
[216] | 46 | |
---|
[189] | 47 | // get the highest priority active IRQ index |
---|
[228] | 48 | if (_icu_get_index( pid / NB_PROCS_MAX, pid % NB_PROCS_MAX, &irq_id)) { |
---|
[203] | 49 | _get_lock(&_tty_put_lock); |
---|
| 50 | _puts("\n[GIET ERROR] Strange... Wrong _icu_read in _irq_demux()\n"); |
---|
| 51 | _release_lock(&_tty_put_lock); |
---|
[189] | 52 | } |
---|
[158] | 53 | |
---|
[216] | 54 | |
---|
[228] | 55 | if (irq_id < 32) { |
---|
| 56 | // do nothing if no interrupt active |
---|
| 57 | unsigned int entry = _get_interrupt_vector_entry(irq_id); |
---|
| 58 | unsigned int isr_id = entry & 0x000000FF; |
---|
| 59 | unsigned int channel_id = (entry >> 16) & 0x0000FFFF; |
---|
| 60 | if ( isr_id == ISR_SWITCH) _isr_switch( channel_id); |
---|
| 61 | else if ( isr_id == ISR_IOC ) _isr_ioc(); |
---|
| 62 | else if ( isr_id == ISR_DMA ) _isr_dma(channel_id); |
---|
| 63 | else if ( isr_id == ISR_TTY ) _isr_tty(channel_id); |
---|
| 64 | else if ( isr_id == ISR_TIMER ) _isr_timer(channel_id); |
---|
| 65 | else _isr_default(); |
---|
[165] | 66 | } |
---|
[158] | 67 | } |
---|
[228] | 68 | |
---|
| 69 | |
---|
[158] | 70 | /////////////////////////////////////////////////////////////////////////////////// |
---|
[228] | 71 | // _isr_default() |
---|
[158] | 72 | // The default ISR is called when no specific ISR has been installed in the |
---|
[203] | 73 | // interrupt vector. It simply displays an error message on kernel TTY[0]. |
---|
[158] | 74 | /////////////////////////////////////////////////////////////////////////////////// |
---|
[228] | 75 | void _isr_default() { |
---|
[203] | 76 | _get_lock(&_tty_put_lock); |
---|
| 77 | _puts("\n[GIET ERROR] Strange... Default ISR activated for processor "); |
---|
| 78 | _putd( _procid() ); |
---|
| 79 | _puts("\n"); |
---|
| 80 | _release_lock(&_tty_put_lock); |
---|
[158] | 81 | } |
---|
[165] | 82 | |
---|
[228] | 83 | |
---|
[158] | 84 | /////////////////////////////////////////////////////////////////////////////////// |
---|
[228] | 85 | // _isr_dma() |
---|
[189] | 86 | // This ISR handles all IRQs generated by the multi-channels DMA controlers. |
---|
| 87 | // The multi_dma components can be distributed in the clusters. |
---|
[207] | 88 | // The channel_id argument is the local DMA channel index. |
---|
| 89 | // dma_global_id = cluster_id*NB_DMAS_MAX + channel_id |
---|
| 90 | // - The ISR saves the transfert status in _dma_status[dma_global_id]. |
---|
[189] | 91 | // - It acknowledges the interrupt to reinitialize the DMA controler. |
---|
[207] | 92 | // - it resets the synchronisation variable _dma_busy[dma_global_id]. |
---|
[158] | 93 | /////////////////////////////////////////////////////////////////////////////////// |
---|
[228] | 94 | void _isr_dma(unsigned int channel_id) { |
---|
[213] | 95 | #if NB_DMAS_MAX > 0 |
---|
[207] | 96 | // compute cluster_id |
---|
[228] | 97 | unsigned int cluster_id = _procid() / NB_PROCS_MAX; |
---|
[158] | 98 | |
---|
[207] | 99 | // compute dma_global_id |
---|
[228] | 100 | unsigned int dma_global_id = cluster_id * NB_DMAS_MAX + channel_id; |
---|
[207] | 101 | |
---|
[169] | 102 | // save DMA channel status |
---|
[228] | 103 | if (_dma_get_status(cluster_id, channel_id, |
---|
| 104 | (unsigned int *) &_dma_status[dma_global_id])) { |
---|
[204] | 105 | _get_lock(&_tty_put_lock); |
---|
| 106 | _puts("[GIET ERROR] illegal DMA channel detected by _isr_dma\n"); |
---|
| 107 | _release_lock(&_tty_put_lock); |
---|
| 108 | return; |
---|
| 109 | } |
---|
[169] | 110 | |
---|
[204] | 111 | // reset DMA channel irq |
---|
[228] | 112 | if (_dma_reset_irq(cluster_id, channel_id)) { |
---|
[204] | 113 | _get_lock(&_tty_put_lock); |
---|
| 114 | _puts("[GIET ERROR] illegal DMA channel detected by _isr_dma\n"); |
---|
| 115 | _release_lock(&_tty_put_lock); |
---|
| 116 | return; |
---|
| 117 | } |
---|
[165] | 118 | |
---|
[169] | 119 | // release DMA channel |
---|
[207] | 120 | _dma_done[dma_global_id] = 1; |
---|
[213] | 121 | #else |
---|
| 122 | _puts("[GIET ERROR] NB_DMAS_MAX is set to zero\n"); |
---|
| 123 | |
---|
| 124 | #endif |
---|
[158] | 125 | } |
---|
[165] | 126 | |
---|
[158] | 127 | /////////////////////////////////////////////////////////////////////////////////// |
---|
[228] | 128 | // _isr_ioc() |
---|
[189] | 129 | // There is only one IOC controler shared by all tasks. |
---|
| 130 | // - The ISR save the status and acknowledge the IRQ. |
---|
| 131 | // - It sets the _ioc_done variable to signal completion. |
---|
[158] | 132 | /////////////////////////////////////////////////////////////////////////////////// |
---|
[228] | 133 | void _isr_ioc() { |
---|
| 134 | // save status & reset IRQ |
---|
| 135 | if (_ioc_get_status((unsigned int *) &_ioc_status )) { |
---|
[204] | 136 | _get_lock(&_tty_put_lock); |
---|
| 137 | _puts("[GIET ERROR] bad access to IOC status detected by _isr_ioc\n"); |
---|
| 138 | _release_lock(&_tty_put_lock); |
---|
| 139 | return; |
---|
| 140 | } |
---|
[158] | 141 | |
---|
[204] | 142 | // signals completion |
---|
[228] | 143 | _ioc_done = 1; |
---|
[158] | 144 | } |
---|
[165] | 145 | |
---|
[228] | 146 | |
---|
[158] | 147 | /////////////////////////////////////////////////////////////////////////////////// |
---|
[228] | 148 | // _isr_timer() |
---|
[203] | 149 | // This ISR handles the IRQs generated by the "user" timers (the IRQs generated |
---|
| 150 | // by the "system" timers should be handled by the _isr_switch(). |
---|
[189] | 151 | // These timers are distributed in all clusters, and can be implemented |
---|
| 152 | // in a vci_multi_timer component, or in a vci_xicu component. |
---|
[207] | 153 | // The timer_id argument is the user timer local index. |
---|
| 154 | // timer_globa_id = cluster_id*(NB_TIMERS_MAX) + timer_id |
---|
[189] | 155 | // The ISR acknowledges the IRQ and registers the event in the proper entry |
---|
[203] | 156 | // of the _timer_event[] array, and a log message is displayed on kernel terminal. |
---|
[158] | 157 | /////////////////////////////////////////////////////////////////////////////////// |
---|
[228] | 158 | void _isr_timer(unsigned int timer_id) { |
---|
[207] | 159 | // compute cluster_id |
---|
[228] | 160 | unsigned int cluster_id = _procid() / NB_PROCS_MAX; |
---|
[158] | 161 | |
---|
[203] | 162 | // aknowledge IRQ |
---|
[228] | 163 | if (_timer_reset_irq( cluster_id, timer_id)) { |
---|
[204] | 164 | _get_lock(&_tty_put_lock); |
---|
| 165 | _puts("[GIET ERROR] illegal timer index detected by _isr_timer\n"); |
---|
| 166 | _release_lock(&_tty_put_lock); |
---|
| 167 | return; |
---|
| 168 | } |
---|
[189] | 169 | |
---|
| 170 | #if NB_TIMERS_MAX |
---|
| 171 | // register the event |
---|
[228] | 172 | unsigned int timer_global_id = cluster_id * NB_TIMERS_MAX + timer_id; |
---|
[207] | 173 | _user_timer_event[timer_global_id] = 1; |
---|
[189] | 174 | #endif |
---|
| 175 | |
---|
| 176 | // display a message on TTY 0 |
---|
[203] | 177 | _get_lock(&_tty_put_lock); |
---|
[207] | 178 | _puts("\n[GIET] User Timer IRQ at cycle "); |
---|
[228] | 179 | _putd(_proctime()); |
---|
[207] | 180 | _puts("\n - cluster_id = "); |
---|
[228] | 181 | _putd(cluster_id); |
---|
[207] | 182 | _puts("\n - timer_id = "); |
---|
[228] | 183 | _putd(timer_id); |
---|
[189] | 184 | _puts("\n"); |
---|
[203] | 185 | _release_lock(&_tty_put_lock); |
---|
[158] | 186 | } |
---|
| 187 | |
---|
[228] | 188 | |
---|
[158] | 189 | /////////////////////////////////////////////////////////////////////////////////// |
---|
[189] | 190 | // _isr_tty() |
---|
| 191 | // This ISR handles the IRQs generated by the multi_tty controler, |
---|
| 192 | // signaling that a character is available. |
---|
[204] | 193 | // There is one single multi_tty component controling all TTYs, |
---|
[207] | 194 | // and the tty_id argument is the global TTY index. |
---|
[189] | 195 | // There is one communication buffer _tty_buf[tty_id] per terminal. |
---|
| 196 | // The sychronisation variable _tty_full[tty_id], is set by the ISR, |
---|
[158] | 197 | // and reset by the OS. |
---|
| 198 | // A character is lost if the buffer is full when the ISR is executed. |
---|
| 199 | /////////////////////////////////////////////////////////////////////////////////// |
---|
[228] | 200 | void _isr_tty(unsigned int tty_id) { |
---|
[189] | 201 | // save character and reset IRQ |
---|
[228] | 202 | if (_tty_get_char( tty_id, (unsigned char *) &_tty_get_buf[tty_id])) { |
---|
[204] | 203 | _get_lock(&_tty_put_lock); |
---|
| 204 | _puts("[GIET ERROR] illegal tty index detected by _isr_tty\n"); |
---|
| 205 | _release_lock(&_tty_put_lock); |
---|
| 206 | return; |
---|
| 207 | } |
---|
[158] | 208 | |
---|
[189] | 209 | // signals character available |
---|
[158] | 210 | _tty_get_full[tty_id] = 1; |
---|
| 211 | } |
---|
| 212 | |
---|
[228] | 213 | |
---|
[158] | 214 | ///////////////////////////////////////////////////////////////////////////////////// |
---|
| 215 | // _isr_switch |
---|
[189] | 216 | // This ISR is in charge of context switch, and handle the IRQs generated by |
---|
| 217 | // the "system" timers. |
---|
| 218 | // The IRQs can be generated by the MULTI_TIMER component or by the XICU component, |
---|
| 219 | // that are distributed in all clusters. |
---|
| 220 | // The ISR acknowledges the IRQ and calls the _ctx_switch() function. |
---|
[158] | 221 | ///////////////////////////////////////////////////////////////////////////////////// |
---|
[228] | 222 | void _isr_switch( unsigned int timer_id) { |
---|
[189] | 223 | // get cluster index and proc local index |
---|
[216] | 224 | unsigned int cluster_id = _procid() / NB_PROCS_MAX; |
---|
[158] | 225 | |
---|
[203] | 226 | // acknowledge IRQ |
---|
[228] | 227 | if (_timer_reset_irq(cluster_id, timer_id)) { |
---|
[204] | 228 | _get_lock(&_tty_put_lock); |
---|
| 229 | _puts("[GIET ERROR] illegal proc index detected by _isr_switch\n"); |
---|
| 230 | _release_lock(&_tty_put_lock); |
---|
| 231 | return; |
---|
| 232 | } |
---|
[158] | 233 | |
---|
[189] | 234 | // performs the context switch |
---|
[158] | 235 | _ctx_switch(); |
---|
| 236 | } |
---|
| 237 | |
---|
[228] | 238 | |
---|
| 239 | // Local Variables: |
---|
| 240 | // tab-width: 4 |
---|
| 241 | // c-basic-offset: 4 |
---|
| 242 | // c-file-offsets:((innamespace . 0)(inline-open . 0)) |
---|
| 243 | // indent-tabs-mode: nil |
---|
| 244 | // End: |
---|
| 245 | // vim: filetype=c:expandtab:shiftwidth=4:tabstop=4:softtabstop=4 |
---|
| 246 | |
---|