Changeset d36d3a3 in rtems


Ignore:
Timestamp:
Nov 1, 2002, 2:21:47 PM (18 years ago)
Author:
Joel Sherrill <joel.sherrill@…>
Branches:
4.10, 4.11, 4.8, 4.9, 5, master
Children:
219bb18
Parents:
7df02840
Message:

2002-11-01 Andy Dachs <a.dachs@…>

  • irq/irq.c, irq/irq_asm.S, irq/irq_init.c: Per PR288, add support for _ISR_Nest_level.
Location:
c/src/lib/libbsp/powerpc/mpc8260ads
Files:
4 edited

Legend:

Unmodified
Added
Removed
  • c/src/lib/libbsp/powerpc/mpc8260ads/ChangeLog

    r7df02840 rd36d3a3  
     12002-11-01      Andy Dachs <a.dachs@sstl.co.uk>
     2
     3        * irq/irq.c, irq/irq_asm.S, irq/irq_init.c: Per PR288, add support
     4        for _ISR_Nest_level.
     5
    162002-10-21      Ralf Corsepius <corsepiu@faw.uni-ulm.de>
    27
  • c/src/lib/libbsp/powerpc/mpc8260ads/irq/irq.c

    r7df02840 rd36d3a3  
    77 *  Modified for mpc8260 Andy Dachs <a.dachs@sstl.co.uk>
    88 *  Surrey Satellite Technology Limited, 2000
    9  *  Nested exception handlers not working yet.
     9+  *    21/4/2002 Added support for nested interrupts and improved
     10+  *    masking operations.  Now we compute priority mask based
     11+  *            on table in irq_init.c
    1012 *
    1113 *  The license and distribution terms for this file may be
     
    1618 */
    1719 
    18 #include <rtems/system.h>
    1920#include <bsp.h>
    2021#include <bsp/irq.h>
     
    2324#include <libcpu/raw_exception.h>
    2425#include <bsp/vectors.h>
    25 /*#include <bsp/8xx_immap.h>*/
     26#include <libcpu/cpu.h>
    2627#include <mpc8260.h>
    27 /*#include <bsp/commproc.h>*/
    2828
    2929/*
     
    4545static inline int is_cpm_irq(const rtems_irq_symbolic_name irqLine)
    4646{
    47   return (((int) irqLine <= BSP_CPM_IRQ_MAX_OFFSET) &
    48           ((int) irqLine >= BSP_CPM_IRQ_LOWEST_OFFSET)
    49          );
     47        return (((int) irqLine <= BSP_CPM_IRQ_MAX_OFFSET) &
     48                        ((int) irqLine >= BSP_CPM_IRQ_LOWEST_OFFSET)
     49        );
    5050}
    5151
     
    5555static inline int is_processor_irq(const rtems_irq_symbolic_name irqLine)
    5656{
    57   return (((int) irqLine <= BSP_PROCESSOR_IRQ_MAX_OFFSET) &
    58           ((int) irqLine >= BSP_PROCESSOR_IRQ_LOWEST_OFFSET)
    59          );
    60 }
    61 
    62 
    63 /*
    64  * bit in the SIU mask registers (PPC bit numbering) that should
    65  * be set to enable the relevant interrupt
    66  *
    67  */
    68 const static unsigned int SIU_MaskBit[BSP_CPM_IRQ_NUMBER] =
    69 {
    70      63, 48, 49, 50,  /* err,   i2c,   spi,   rtt   */
    71      51, 52, 53, 54,  /* smc1,  smc2,  idma1, idma2 */
    72      55, 56, 57, 63,  /* idma3, idma4, sdma,  -     */
    73      59, 60, 61, 62,  /* tmr1,  tmr2,  tmr3,  tmr4  */
    74      29, 30, 63, 17,  /* pit,   tmcnt, -,     irq1  */
    75      18, 19, 20, 21,  /* irq2,  irq3,  irq4,  irq5  */
    76      22, 23, 63, 63,  /* irq6,  irq7,  -,     -     */
    77      63, 63, 63, 63,  /* -,     -,     -,     -     */
    78      32, 33, 34, 35,  /* fcc1,  fcc2,  fcc3,  -     */
    79      36, 37, 38, 39,  /* mcc1,  mcc2,  -,     -     */
    80      40, 41, 42, 43,  /* scc1,  scc2,  scc3,  scc4  */
    81      44, 45, 46, 47,  /* -,     -,     -,     -     */
    82      0,  1,   2,  3,  /* pc0,   pc1,   pc2,   pc3   */
    83      4,  5,   6,  7,  /* pc4,   pc5,   pc6,   pc7   */
    84      8,  9,  10, 11,  /* pc8,   pc9,   pc10,  pc11  */
    85      12, 13, 14, 15   /* pc12,  pc13,  pc14,  pc15  */
     57        return (((int) irqLine <= BSP_PROCESSOR_IRQ_MAX_OFFSET) &
     58                        ((int) irqLine >= BSP_PROCESSOR_IRQ_LOWEST_OFFSET)
     59        );
     60}
     61
     62typedef struct {
     63        rtems_unsigned32 mask_h;        /* mask for sipnr_h and simr_h */
     64        rtems_unsigned32 mask_l;        /* mask for sipnr_l and simr_l */
     65        rtems_unsigned32 priority_h;  /* mask this and lower priority ints */
     66        rtems_unsigned32 priority_l;
     67} m82xxIrqMasks_t;
     68
     69/*
     70 *  Mask fields should have a '1' in the bit position for that
     71 *  interrupt.
     72 *      Priority masks calculated later based on priority table
     73 */
     74
     75static m82xxIrqMasks_t SIU_MaskBit[BSP_CPM_IRQ_NUMBER] =
     76{
     77        { 0x00000000, 0x00000000, 0x00000000, 0x00000000 }, /* err */
     78        { 0x00000000, 0x00008000, 0x00000000, 0x00000000 }, /* i2c */
     79        { 0x00000000, 0x00004000, 0x00000000, 0x00000000 }, /* spi */
     80        { 0x00000000, 0x00002000, 0x00000000, 0x00000000 }, /* rtt */
     81        { 0x00000000, 0x00001000, 0x00000000, 0x00000000 }, /* smc1 */
     82        { 0x00000000, 0x00000800, 0x00000000, 0x00000000 }, /* smc2 */
     83        { 0x00000000, 0x00000400, 0x00000000, 0x00000000 }, /* idma1 */
     84        { 0x00000000, 0x00000200, 0x00000000, 0x00000000 }, /* idma2 */
     85        { 0x00000000, 0x00000100, 0x00000000, 0x00000000 }, /* idma3 */
     86        { 0x00000000, 0x00000080, 0x00000000, 0x00000000 }, /* idma4 */
     87        { 0x00000000, 0x00000040, 0x00000000, 0x00000000 }, /* sdma */
     88        { 0x00000000, 0x00000000, 0x00000000, 0x00000000 }, /* reserved */
     89        { 0x00000000, 0x00000010, 0x00000000, 0x00000000 }, /* tmr1 */
     90        { 0x00000000, 0x00000008, 0x00000000, 0x00000000 }, /* tmr2 */
     91        { 0x00000000, 0x00000004, 0x00000000, 0x00000000 }, /* tmr3 */
     92        { 0x00000000, 0x00000002, 0x00000000, 0x00000000 }, /* tmr4 */
     93        { 0x00000004, 0x00000000, 0x00000000, 0x00000000 }, /* tmcnt */
     94        { 0x00000002, 0x00000000, 0x00000000, 0x00000000 }, /* pit */
     95        { 0x00000000, 0x00000000, 0x00000000, 0x00000000 }, /* reserved */
     96        { 0x00004000, 0x00000000, 0x00000000, 0x00000000 }, /* irq1 */
     97        { 0x00002000, 0x00000000, 0x00000000, 0x00000000 }, /* irq2 */
     98        { 0x00001000, 0x00000000, 0x00000000, 0x00000000 }, /* irq3 */
     99        { 0x00000800, 0x00000000, 0x00000000, 0x00000000 }, /* irq4 */
     100        { 0x00000400, 0x00000000, 0x00000000, 0x00000000 }, /* irq5 */
     101        { 0x00000200, 0x00000000, 0x00000000, 0x00000000 }, /* irq6 */
     102        { 0x00000100, 0x00000000, 0x00000000, 0x00000000 }, /* irq7 */
     103        { 0x00000000, 0x00000000, 0x00000000, 0x00000000 }, /* reserved */
     104        { 0x00000000, 0x00000000, 0x00000000, 0x00000000 }, /* reserved */
     105        { 0x00000000, 0x00000000, 0x00000000, 0x00000000 }, /* reserved */
     106        { 0x00000000, 0x00000000, 0x00000000, 0x00000000 }, /* reserved */
     107        { 0x00000000, 0x00000000, 0x00000000, 0x00000000 }, /* reserved */
     108        { 0x00000000, 0x00000000, 0x00000000, 0x00000000 }, /* reserved */
     109        { 0x00000000, 0x80000000, 0x00000000, 0x00000000 }, /* fcc1 */
     110        { 0x00000000, 0x40000000, 0x00000000, 0x00000000 }, /* fcc2 */
     111        { 0x00000000, 0x20000000, 0x00000000, 0x00000000 }, /* fcc3 */
     112        { 0x00000000, 0x00000000, 0x00000000, 0x00000000 }, /* reserved */
     113        { 0x00000000, 0x08000000, 0x00000000, 0x00000000 }, /* mcc1 */
     114        { 0x00000000, 0x04000000, 0x00000000, 0x00000000 }, /* mcc2 */
     115        { 0x00000000, 0x00000000, 0x00000000, 0x00000000 }, /* reserved */
     116        { 0x00000000, 0x00000000, 0x00000000, 0x00000000 }, /* reserved */
     117        { 0x00000000, 0x00800000, 0x00000000, 0x00000000 }, /* scc1 */
     118        { 0x00000000, 0x00400000, 0x00000000, 0x00000000 }, /* scc2 */
     119        { 0x00000000, 0x00200000, 0x00000000, 0x00000000 }, /* scc3 */
     120        { 0x00000000, 0x00100000, 0x00000000, 0x00000000 }, /* scc4 */
     121        { 0x00000000, 0x00000000, 0x00000000, 0x00000000 }, /* reserved */
     122        { 0x00000000, 0x00000000, 0x00000000, 0x00000000 }, /* reserved */
     123        { 0x00000000, 0x00000000, 0x00000000, 0x00000000 }, /* reserved */
     124        { 0x00000000, 0x00000000, 0x00000000, 0x00000000 }, /* reserved */
     125        { 0x00010000, 0x00000000, 0x00000000, 0x00000000 }, /* pc15 */
     126        { 0x00020000, 0x00000000, 0x00000000, 0x00000000 }, /* pc14 */
     127        { 0x00040000, 0x00000000, 0x00000000, 0x00000000 }, /* pc13 */
     128        { 0x00080000, 0x00000000, 0x00000000, 0x00000000 }, /* pc12 */
     129        { 0x00100000, 0x00000000, 0x00000000, 0x00000000 }, /* pc11 */
     130        { 0x00200000, 0x00000000, 0x00000000, 0x00000000 }, /* pc10 */
     131        { 0x00400000, 0x00000000, 0x00000000, 0x00000000 }, /* pc9 */
     132        { 0x00800000, 0x00000000, 0x00000000, 0x00000000 }, /* pc8 */
     133        { 0x01000000, 0x00000000, 0x00000000, 0x00000000 }, /* pc7 */
     134        { 0x02000000, 0x00000000, 0x00000000, 0x00000000 }, /* pc6 */
     135        { 0x04000000, 0x00000000, 0x00000000, 0x00000000 }, /* pc5 */
     136        { 0x08000000, 0x00000000, 0x00000000, 0x00000000 }, /* pc4 */
     137        { 0x10000000, 0x00000000, 0x00000000, 0x00000000 }, /* pc3 */
     138        { 0x20000000, 0x00000000, 0x00000000, 0x00000000 }, /* pc2 */
     139        { 0x40000000, 0x00000000, 0x00000000, 0x00000000 }, /* pc1 */
     140        { 0x80000000, 0x00000000, 0x00000000, 0x00000000 }, /* pc0 */
     141
    86142};
     143
     144
     145
     146void dump_irq_masks(void )
     147{
     148        int i;
     149        for( i=0; i<BSP_CPM_IRQ_NUMBER;i++ )   
     150        {
     151                printk( "%04d: %08X %08X\n",
     152                        i,
     153                        SIU_MaskBit[i].priority_h,
     154                        SIU_MaskBit[i].priority_l
     155                );
     156        }
     157}
    87158
    88159/*
     
    97168static void compute_SIU_IvectMask_from_prio ()
    98169{
    99   /*
    100    * In theory this is feasible. No time to code it yet. See i386/shared/irq.c
    101    * for an example based on 8259 controller mask. The actual masks defined
    102    * correspond to the priorities defined for the SIU in irq_init.c.
    103    */
     170        /*
     171         * The actual masks defined
     172         * correspond to the priorities defined
     173         * for the SIU in irq_init.c.
     174         */
     175       
     176         int i,j;
     177       
     178         for( i=0; i<BSP_CPM_IRQ_NUMBER; i++ )
     179         {
     180                for( j=0;j<BSP_CPM_IRQ_NUMBER; j++ )
     181                        if( internal_config->irqPrioTbl[j] < internal_config->irqPrioTbl[i] )
     182                        {
     183                                SIU_MaskBit[i].priority_h |= SIU_MaskBit[j].mask_h;
     184                                SIU_MaskBit[i].priority_l |= SIU_MaskBit[j].mask_l;
     185                        }                               
     186         }
     187       
    104188}
    105189
     
    111195static int isValidInterrupt(int irq)
    112196{
    113   if ( (irq < BSP_LOWEST_OFFSET) || (irq > BSP_MAX_OFFSET) )
    114     return 0;
    115   return 1;
     197        if ( (irq < BSP_LOWEST_OFFSET) || (irq > BSP_MAX_OFFSET) )
     198                return 0;
     199        return 1;
    116200}
    117201
    118202int BSP_irq_enable_at_cpm(const rtems_irq_symbolic_name irqLine)
    119203{
    120   int cpm_irq_index;
    121 
    122   if (!is_cpm_irq(irqLine))
    123     return 1;
    124 
    125   cpm_irq_index = ((int) (irqLine) - BSP_CPM_IRQ_LOWEST_OFFSET);
    126 
    127 
    128   if( SIU_MaskBit[cpm_irq_index] < 32 )
    129      m8260.simr_h |= (0x80000000 >> SIU_MaskBit[cpm_irq_index]);
    130   else
    131      m8260.simr_l |= (0x80000000 >> (SIU_MaskBit[cpm_irq_index]-32));
    132 
    133   return 0;
     204        int cpm_irq_index;
     205
     206        if (!is_cpm_irq(irqLine))
     207                return 1;
     208
     209        cpm_irq_index = ((int) (irqLine) - BSP_CPM_IRQ_LOWEST_OFFSET);
     210
     211        m8260.simr_h |= SIU_MaskBit[cpm_irq_index].mask_h;
     212        m8260.simr_l |= SIU_MaskBit[cpm_irq_index].mask_l;
     213
     214        return 0;
    134215}
    135216
    136217int BSP_irq_disable_at_cpm(const rtems_irq_symbolic_name irqLine)
    137218{
    138   int cpm_irq_index;
    139  
    140   if (!is_cpm_irq(irqLine))
    141     return 1;
    142  
    143   cpm_irq_index = ((int) (irqLine) - BSP_CPM_IRQ_LOWEST_OFFSET);
    144 
    145   if( SIU_MaskBit[cpm_irq_index] < 32 )
    146      m8260.simr_h &= ~(0x80000000 >> SIU_MaskBit[cpm_irq_index]);
    147   else
    148      m8260.simr_l &= ~(0x80000000 >> (SIU_MaskBit[cpm_irq_index]-32));
    149 
    150 
    151   return 0;
     219        int cpm_irq_index;
     220 
     221        if (!is_cpm_irq(irqLine))
     222                return 1;
     223 
     224        cpm_irq_index = ((int) (irqLine) - BSP_CPM_IRQ_LOWEST_OFFSET);
     225
     226        m8260.simr_h &= ~(SIU_MaskBit[cpm_irq_index].mask_h);
     227        m8260.simr_l &= ~(SIU_MaskBit[cpm_irq_index].mask_l);
     228
     229
     230        return 0;
    152231}
    153232
    154233int BSP_irq_enabled_at_cpm(const rtems_irq_symbolic_name irqLine)
    155234{
    156   int cpm_irq_index;
    157  
    158   if (!is_cpm_irq(irqLine))
    159     return 0;
    160  
    161   cpm_irq_index = ((int) (irqLine) - BSP_CPM_IRQ_LOWEST_OFFSET);
    162 
    163   if( SIU_MaskBit[cpm_irq_index] < 32 )
    164      return m8260.simr_h & (0x80000000 >> SIU_MaskBit[cpm_irq_index]);
    165   else
    166      return m8260.simr_l & (0x80000000 >> (SIU_MaskBit[cpm_irq_index]-32));
     235        int cpm_irq_index;
     236 
     237        if (!is_cpm_irq(irqLine))
     238                return 0;
     239 
     240        cpm_irq_index = ((int) (irqLine) - BSP_CPM_IRQ_LOWEST_OFFSET);
     241
     242        return ((m8260.simr_h & SIU_MaskBit[cpm_irq_index].mask_h) ||
     243                    (m8260.simr_l & SIU_MaskBit[cpm_irq_index].mask_l));
    167244}
    168245
     
    174251int BSP_install_rtems_irq_handler  (const rtems_irq_connect_data* irq)
    175252{
    176     unsigned int level;
    177  
    178     if (!isValidInterrupt(irq->name)) {
    179       printk( "not a valid intr\n" ) ;
    180       return 0;
    181     }
    182     /*
    183      * Check if default handler is actually connected. If not issue an error.
    184      * You must first get the current handler via i386_get_current_idt_entry
    185      * and then disconnect it using i386_delete_idt_entry.
    186      * RATIONALE : to always have the same transition by forcing the user
    187      * to get the previous handler before accepting to disconnect.
    188      */
    189     if (rtems_hdl_tbl[irq->name].hdl != default_rtems_entry.hdl) {
    190       printk( "Default handler not there\n" );
    191       return 0;
    192     }
    193 
    194     _CPU_ISR_Disable(level);
    195 
    196     /*
    197      * store the data provided by user
    198      */
    199     rtems_hdl_tbl[irq->name] = *irq;
    200    
    201     if (is_cpm_irq(irq->name)) {
    202       /*
    203        * Enable interrupt at PIC level
    204        */
    205       BSP_irq_enable_at_cpm (irq->name);
    206     }
    207    
    208 
    209     if (is_processor_irq(irq->name)) {
    210       /*
    211        * Should Enable exception at processor level but not needed.  Will restore
    212        * EE flags at the end of the routine anyway.
    213        */
    214     }
    215     /*
    216      * Enable interrupt on device
    217      */
    218     irq->on(irq);
    219    
    220     _CPU_ISR_Enable(level);
    221 
    222 /*
    223     printk( "Enabled\n" );
    224 */
    225     return 1;
     253        unsigned int level;
     254
     255        if (!isValidInterrupt(irq->name)) {
     256                printk( "not a valid intr\n" ) ;
     257                return 0;
     258        }
     259        /*
     260         * Check if default handler is actually connected. If not issue an error.
     261         * You must first get the current handler via i386_get_current_idt_entry
     262         * and then disconnect it using i386_delete_idt_entry.
     263         * RATIONALE : to always have the same transition by forcing the user
     264         * to get the previous handler before accepting to disconnect.
     265         */
     266        if (rtems_hdl_tbl[irq->name].hdl != default_rtems_entry.hdl) {
     267                printk( "Default handler not there\n" );
     268                return 0;
     269        }
     270
     271        _CPU_ISR_Disable(level);
     272
     273        /*
     274         * store the data provided by user
     275         */
     276        rtems_hdl_tbl[irq->name] = *irq;
     277       
     278        if (is_cpm_irq(irq->name)) {
     279            /*
     280             * Enable interrupt at PIC level
     281             */
     282            BSP_irq_enable_at_cpm (irq->name);
     283        }
     284
     285#if 0
     286        if (is_processor_irq(irq->name)) {
     287                /*
     288                 * Should Enable exception at processor level but not needed.  Will restore
     289                 * EE flags at the end of the routine anyway.
     290                 */
     291        }
     292#endif
     293
     294        /*
     295         * Enable interrupt on device
     296         */
     297        irq->on(irq);
     298
     299        _CPU_ISR_Enable(level);
     300
     301        /*
     302            printk( "Enabled\n" );
     303        */
     304        return 1;
    226305}
    227306
     
    229308int BSP_get_current_rtems_irq_handler   (rtems_irq_connect_data* irq)
    230309{
    231      if (!isValidInterrupt(irq->name)) {
    232       return 0;
    233      }
    234      *irq = rtems_hdl_tbl[irq->name];
    235      return 1;
     310        if (!isValidInterrupt(irq->name)) {
     311                return 0;
     312        }
     313        *irq = rtems_hdl_tbl[irq->name];
     314        return 1;
    236315}
    237316
    238317int BSP_remove_rtems_irq_handler  (const rtems_irq_connect_data* irq)
    239318{
    240     unsigned int level;
    241  
    242     if (!isValidInterrupt(irq->name)) {
    243       return 0;
    244     }
    245     /*
    246     * Check if default handler is actually connected. If not issue an error.
    247     * You must first get the current handler via i386_get_current_idt_entry
    248     * and then disconnect it using i386_delete_idt_entry.
    249     * RATIONALE : to always have the same transition by forcing the user
    250     * to get the previous handler before accepting to disconnect.
    251     */
    252     if (rtems_hdl_tbl[irq->name].hdl != irq->hdl) {
    253       return 0;
    254     }
    255     _CPU_ISR_Disable(level);
    256 
    257     if (is_cpm_irq(irq->name)) {
    258       /*
    259        * disable interrupt at PIC level
    260        */
    261       BSP_irq_disable_at_cpm (irq->name);
    262     }
    263 
    264     if (is_processor_irq(irq->name)) {
    265       /*
    266        * disable exception at processor level
    267        */
    268     }   
    269 
    270     /*
    271     * Disable interrupt on device
    272     */
    273     irq->off(irq);
    274 
    275     /*
    276     * restore the default irq value
    277     */
    278     rtems_hdl_tbl[irq->name] = default_rtems_entry;
    279 
    280     _CPU_ISR_Enable(level);
    281 
    282     return 1;
     319        unsigned int level;
     320 
     321        if (!isValidInterrupt(irq->name)) {
     322                return 0;
     323        }
     324        /*
     325        * Check if default handler is actually connected. If not issue an error.
     326        * You must first get the current handler via i386_get_current_idt_entry
     327        * and then disconnect it using i386_delete_idt_entry.
     328        * RATIONALE : to always have the same transition by forcing the user
     329        * to get the previous handler before accepting to disconnect.
     330        */
     331        if (rtems_hdl_tbl[irq->name].hdl != irq->hdl) {
     332          return 0;
     333        }
     334        _CPU_ISR_Disable(level);
     335       
     336        if (is_cpm_irq(irq->name)) {
     337          /*
     338           * disable interrupt at PIC level
     339           */
     340          BSP_irq_disable_at_cpm (irq->name);
     341        }
     342       
     343        if (is_processor_irq(irq->name)) {
     344          /*
     345           * disable exception at processor level
     346           */
     347        }   
     348       
     349        /*
     350        * Disable interrupt on device
     351        */
     352        irq->off(irq);
     353       
     354        /*
     355        * restore the default irq value
     356        */
     357        rtems_hdl_tbl[irq->name] = default_rtems_entry;
     358       
     359        _CPU_ISR_Enable(level);
     360       
     361        return 1;
    283362}
    284363
     
    289368int BSP_rtems_irq_mngt_set(rtems_irq_global_settings* config)
    290369{
    291     int i;
    292     unsigned int level;
    293    /*
    294     * Store various code accelerators
    295     */
    296     internal_config             = config;
    297     default_rtems_entry         = config->defaultEntry;
    298     rtems_hdl_tbl               = config->irqHdlTbl;
    299 
    300     _CPU_ISR_Disable(level);
    301     /*
    302      * start with CPM IRQ
    303      */
    304     for (i=BSP_CPM_IRQ_LOWEST_OFFSET; i < BSP_CPM_IRQ_LOWEST_OFFSET + BSP_CPM_IRQ_NUMBER ; i++) {
    305       if (rtems_hdl_tbl[i].hdl != default_rtems_entry.hdl) {
    306         BSP_irq_enable_at_cpm (i);
    307         rtems_hdl_tbl[i].on(&rtems_hdl_tbl[i]);
    308       }
    309       else {
    310         rtems_hdl_tbl[i].off(&rtems_hdl_tbl[i]);
    311         BSP_irq_disable_at_cpm (i);
    312       }
    313     }
    314 
    315     /*
    316      * finish with Processor exceptions handled like IRQ
    317      */
    318     for (i=BSP_PROCESSOR_IRQ_LOWEST_OFFSET; i < BSP_PROCESSOR_IRQ_LOWEST_OFFSET + BSP_PROCESSOR_IRQ_NUMBER; i++) {
    319       if (rtems_hdl_tbl[i].hdl != default_rtems_entry.hdl) {
    320         rtems_hdl_tbl[i].on(&rtems_hdl_tbl[i]);
    321       }
    322       else {
    323         rtems_hdl_tbl[i].off(&rtems_hdl_tbl[i]);
    324       }
    325     }
    326     _CPU_ISR_Enable(level);
    327     return 1;
     370        int i;
     371        unsigned int level;
     372        /*
     373         * Store various code accelerators
     374         */
     375        internal_config                 = config;
     376        default_rtems_entry             = config->defaultEntry;
     377        rtems_hdl_tbl           = config->irqHdlTbl;
     378
     379        /* Fill in priority masks */
     380        compute_SIU_IvectMask_from_prio();
     381       
     382        _CPU_ISR_Disable(level);
     383        /*
     384         * start with CPM IRQ
     385         */
     386        for (i=BSP_CPM_IRQ_LOWEST_OFFSET; i < BSP_CPM_IRQ_LOWEST_OFFSET + BSP_CPM_IRQ_NUMBER ; i++) {
     387                if (rtems_hdl_tbl[i].hdl != default_rtems_entry.hdl) {
     388                        BSP_irq_enable_at_cpm (i);
     389                        rtems_hdl_tbl[i].on(&rtems_hdl_tbl[i]);
     390                } else {
     391                        rtems_hdl_tbl[i].off(&rtems_hdl_tbl[i]);
     392                        BSP_irq_disable_at_cpm (i);
     393                }
     394        }
     395
     396        /*
     397         * finish with Processor exceptions handled like IRQ
     398         */
     399        for (i=BSP_PROCESSOR_IRQ_LOWEST_OFFSET; i < BSP_PROCESSOR_IRQ_LOWEST_OFFSET + BSP_PROCESSOR_IRQ_NUMBER; i++) {
     400                if (rtems_hdl_tbl[i].hdl != default_rtems_entry.hdl) {
     401                        rtems_hdl_tbl[i].on(&rtems_hdl_tbl[i]);
     402                } else {
     403                        rtems_hdl_tbl[i].off(&rtems_hdl_tbl[i]);
     404                }
     405        }
     406
     407        _CPU_ISR_Enable(level);
     408        return 1;
    328409}
    329410
    330411int BSP_rtems_irq_mngt_get(rtems_irq_global_settings** config)
    331412{
    332     *config = internal_config;
    333     return 0;
     413        *config = internal_config;
     414        return 0;
    334415}
    335416
     
    338419#endif
    339420
     421
    340422/*
    341423 * High level IRQ handler called from shared_raw_irq_code_entry
     
    343425void C_dispatch_irq_handler (CPU_Interrupt_frame *frame, unsigned int excNum)
    344426{
    345   register unsigned int irq;
     427        register unsigned int irq;
    346428#if 0
    347   register unsigned oldMask;                  /* old siu pic masks */
     429        register unsigned oldMask;                    /* old siu pic masks */
    348430#endif
    349   register unsigned msr;
    350   register unsigned new_msr;
     431        register unsigned msr;
     432        register unsigned new_msr;
     433        register unsigned old_simr_h;
     434        register unsigned old_simr_l;
    351435#ifdef DISPATCH_HANDLER_STAT
    352   unsigned loopCounter;
     436        unsigned loopCounter;
    353437#endif
    354438
    355439
    356440
    357   /*
    358    * Handle decrementer interrupt
    359    */
    360   if (excNum == ASM_DEC_VECTOR) {
    361 
    362 /*
    363     _BSP_GPLED1_on();
    364 */
    365     _CPU_MSR_GET(msr);
    366     new_msr = msr | MSR_EE;
    367     _CPU_MSR_SET(new_msr);
    368 
    369     rtems_hdl_tbl[BSP_DECREMENTER].hdl();
    370 
    371     _CPU_MSR_SET(msr);
    372 
    373 /*
    374     _BSP_GPLED1_off();
    375 */
    376     return;
    377   }
    378 
    379   /*
    380    * Handle external interrupt generated by SIU on PPC core
    381    */
     441        /*
     442         * Handle decrementer interrupt
     443         */
     444        if (excNum == ASM_DEC_VECTOR) {
     445                _CPU_MSR_GET(msr);
     446                new_msr = msr | MSR_EE;
     447                _CPU_MSR_SET(new_msr);
     448
     449                rtems_hdl_tbl[BSP_DECREMENTER].hdl();
     450
     451                _CPU_MSR_SET(msr);
     452
     453                return;
     454        }
     455
     456        /*
     457         * Handle external interrupt generated by SIU on PPC core
     458         */
    382459#ifdef DISPATCH_HANDLER_STAT
    383   loopCounter = 0;
     460        loopCounter = 0;
    384461#endif 
    385   while (1) {
    386 
    387     if( ((m8260.sipnr_h & m8260.simr_h) | (m8260.sipnr_l & m8260.simr_l)) == 0 ) {
     462
     463        while (1) {
     464
     465                if( ((m8260.sipnr_h & m8260.simr_h) | (m8260.sipnr_l & m8260.simr_l)) == 0 ) {
    388466#ifdef DISPATCH_HANDLER_STAT
    389       if (loopCounter >  maxLoop) maxLoop = loopCounter;
     467                        if (loopCounter >  maxLoop) maxLoop = loopCounter;
    390468#endif     
    391       break;
    392     }
    393 
    394     irq = (m8260.sivec >> 26) + BSP_CPM_IRQ_LOWEST_OFFSET;
    395 
    396 /*
    397     printk( "dispatching %d\n", irq );
    398 */
    399 
    400     /* Clear pending register */
    401     if( irq <= BSP_CPM_IRQ_MAX_OFFSET ) {
    402       if( SIU_MaskBit[irq] < 32 )
    403         m8260.sipnr_h = (0x80000000 >> SIU_MaskBit[irq]);
    404       else
    405         m8260.sipnr_l = (0x80000000 >> (SIU_MaskBit[irq]-32));
    406     }
    407 
    408 /*
    409     _CPU_MSR_GET(msr);
    410     new_msr = msr | MSR_EE;
    411     _CPU_MSR_SET(new_msr);
    412 */
    413     rtems_hdl_tbl[irq].hdl();
    414 /*
    415     _CPU_MSR_SET(msr);
    416 */
    417 
    418 
    419 
    420 #if 0
    421     ppc_cached_irq_mask |= (oldMask & ~(SIU_IvectMask[irq]));
    422     ((volatile immap_t *)IMAP_ADDR)->im_siu_conf.sc_simask = ppc_cached_irq_mask;
     469                        break;
     470                }
     471
     472                irq = (m8260.sivec >> 26) + BSP_CPM_IRQ_LOWEST_OFFSET;
     473
     474                /* Clear mask and pending register */
     475                if( irq <= BSP_CPM_IRQ_MAX_OFFSET ) {
     476                        /* save interrupt masks */
     477                        old_simr_h = m8260.simr_h;
     478                        old_simr_l = m8260.simr_l;
     479
     480                        /* mask off current interrupt and lower priority ones */
     481                        m8260.simr_h &= SIU_MaskBit[irq].priority_h;
     482                        m8260.simr_l &= SIU_MaskBit[irq].priority_l;
     483
     484                        /* clear pending bit */
     485                        m8260.sipnr_h |= SIU_MaskBit[irq].mask_h;
     486                        m8260.sipnr_l |= SIU_MaskBit[irq].mask_l;
     487
     488                        /* re-enable external exceptions */
     489                        _CPU_MSR_GET(msr);
     490                        new_msr = msr | MSR_EE;
     491                        _CPU_MSR_SET(new_msr);
     492
     493                        /* call handler */
     494                        rtems_hdl_tbl[irq].hdl();
     495
     496                        /* disable exceptions again */
     497                        _CPU_MSR_SET(msr);
     498                       
     499                        /* restore interrupt masks */
     500                        m8260.simr_h = old_simr_h;
     501                        m8260.simr_l = old_simr_l;
     502                       
     503                }
     504#ifdef DISPATCH_HANDLER_STAT
     505                ++ loopCounter;
    423506#endif
    424 #ifdef DISPATCH_HANDLER_STAT
    425     ++ loopCounter;
    426 #endif   
    427   }
    428 
    429 
    430 
    431 
     507        }
    432508}
    433509
     
    436512void _ThreadProcessSignalsFromIrq (BSP_Exception_frame* ctx)
    437513{
    438   /*
    439    * Process pending signals that have not already been
    440    * processed by _Thread_Displatch. This happens quite
    441    * unfrequently : the ISR must have posted an action
    442    * to the current running thread.
    443    */
    444   if ( _Thread_Do_post_task_switch_extension ||
    445        _Thread_Executing->do_post_task_switch_extension ) {
    446     _Thread_Executing->do_post_task_switch_extension = FALSE;
    447     _API_extensions_Run_postswitch();
    448   }
    449   /*
    450    * I plan to process other thread related events here.
    451    * This will include DEBUG session requested from keyboard...
    452    */
    453 }
     514        /*
     515         * Process pending signals that have not already been
     516         * processed by _Thread_Displatch. This happens quite
     517         * unfrequently : the ISR must have posted an action
     518         * to the current running thread.
     519         */
     520        if ( _Thread_Do_post_task_switch_extension ||
     521                _Thread_Executing->do_post_task_switch_extension ) {
     522                _Thread_Executing->do_post_task_switch_extension = FALSE;
     523                _API_extensions_Run_postswitch();
     524        }
     525
     526        /*
     527         * I plan to process other thread related events here.
     528         * This will include DEBUG session requested from keyboard...
     529         */
     530}
  • c/src/lib/libbsp/powerpc/mpc8260ads/irq/irq_asm.S

    r7df02840 rd36d3a3  
    1010 *  Modifications Copyright (C) 1999 Eric Valette. valette@crf.canon.fr
    1111 *
     12 *  Modifications to store nesting level in global _ISR_Nest_level
     13 *  variable instead of SPRG0.  Andy Dachs <a.dachs@sstl.co.uk>
    1214 *
    1315 * $Id$
    1416 */
    1517       
    16 #include <asm.h>
     18#include <bsp/vectors.h>
     19#include <rtems/score/cpuopts.h>  /* for PPC_HAS_FPU */
    1720#include <rtems/score/cpu.h>
    18 #include <bsp/vectors.h>
     21#include <libcpu/cpu.h>
    1922#include <libcpu/raw_exception.h>
    20        
     23#include "asm.h"
    2124
    2225#define SYNC \
     
    2730        .p2align 5     
    2831               
     32       
    2933        PUBLIC_VAR(decrementer_exception_vector_prolog_code)
    3034       
     
    8488        stw     r0, SRR0_FRAME_OFFSET(r1)
    8589        stw     r2, SRR1_FRAME_OFFSET(r1)
    86        
    8790
    8891        /*
     
    107110         * switch to the right stack later.
    108111         */
    109         stw     r5, GPR5_OFFSET(r1)
    110         stw     r6, GPR6_OFFSET(r1)
    111         stw     r7, GPR7_OFFSET(r1)
    112         stw     r8, GPR8_OFFSET(r1)
    113         stw     r9, GPR9_OFFSET(r1)
    114         stw     r10, GPR10_OFFSET(r1)
    115         stw     r11, GPR11_OFFSET(r1)
    116         stw     r12, GPR12_OFFSET(r1)
    117         stw     r13, GPR13_OFFSET(r1)
     112        stw             r5, GPR5_OFFSET(r1)
     113        stw             r6, GPR6_OFFSET(r1)
     114        stw             r7, GPR7_OFFSET(r1)
     115        stw             r8, GPR8_OFFSET(r1)
     116        stw             r9, GPR9_OFFSET(r1)
     117        stw             r10, GPR10_OFFSET(r1)
     118        stw             r11, GPR11_OFFSET(r1)
     119        stw             r12, GPR12_OFFSET(r1)
     120        stw             r13, GPR13_OFFSET(r1)
    118121
    119122        mfcr    r5
     
    122125        mflr    r8
    123126       
    124         stw     r5,  EXC_CR_OFFSET(r1)
    125         stw     r6,  EXC_CTR_OFFSET(r1)
    126         stw     r7,  EXC_XER_OFFSET(r1)
    127         stw     r8,  EXC_LR_OFFSET(r1)
     127        stw             r5,  EXC_CR_OFFSET(r1)
     128        stw             r6,  EXC_CTR_OFFSET(r1)
     129        stw             r7,  EXC_XER_OFFSET(r1)
     130        stw             r8,  EXC_LR_OFFSET(r1)
    128131
    129132        /*
     
    131134         * that will be used when returning from C handler
    132135         */
    133         stw     r14, GPR14_OFFSET(r1)
    134         stw     r15, GPR15_OFFSET(r1)
     136        stw             r14, GPR14_OFFSET(r1)
     137        stw             r15, GPR15_OFFSET(r1)
    135138        /*
    136139         * save current stack pointer location in R14
     
    140143         * store part of _Thread_Dispatch_disable_level address in R15
    141144         */
    142         addis r15,0, _Thread_Dispatch_disable_level@ha
     145        addis   r15,0, _Thread_Dispatch_disable_level@ha
    143146        /*
    144147         * Get current nesting level in R2
    145148         */
    146         mfspr   r2, SPRG0
     149/*      mfspr   r2, SPRG0 */
     150        addis   r6, 0, _ISR_Nest_level@ha
     151        lwz             r2, _ISR_Nest_level@l( r6 )
     152       
    147153        /*
    148154         * Check if stack switch is necessary
    149155         */
    150156        cmpwi   r2,0
    151         bne     nested
     157        bne             nested
    152158        mfspr   r1, SPRG1
    153159       
     
    157163         */
    158164        addi    r2,r2,1
     165       
     166        addis   r6, 0, _ISR_Nest_level@ha
     167        stw             r2, _ISR_Nest_level@l( r6 )
     168       
    159169        /*
    160170         * Start Incrementing _Thread_Dispatch_disable_level R4 = _Thread_Dispatch_disable_level
    161171         */
    162         lwz     r6,_Thread_Dispatch_disable_level@l(r15)
     172        lwz             r6,_Thread_Dispatch_disable_level@l(r15)
    163173        /*
    164174         * store new nesting level in SPRG0
    165175         */
    166         mtspr   SPRG0, r2
     176/*      mtspr   SPRG0, r2 */
    167177       
    168178        addi    r6, r6, 1
     
    171181         * store new _Thread_Dispatch_disable_level value
    172182         */
    173         stw     r6, _Thread_Dispatch_disable_level@l(r15)
     183        stw             r6, _Thread_Dispatch_disable_level@l(r15)
    174184        /*
    175185         * We are now running on the interrupt stack. External and decrementer
     
    181191         * in case...
    182192         */
     193       
    183194        addi    r3, r14, 0x8
    184         bl      C_dispatch_irq_handler /* C_dispatch_irq_handler(cpu_interrupt_frame* r3, vector r4) */
     195        bl              C_dispatch_irq_handler /* C_dispatch_irq_handler(cpu_interrupt_frame* r3, vector r4) */
     196
    185197        /*
    186198         * start decrementing nesting level. Note : do not test result against 0
     
    188200         * then _Thread_Dispatch_disable_level > 1
    189201         */
    190         mfspr   r2, SPRG0
     202/*      mfspr   r2, SPRG0 */
     203       
     204        addis   r6, 0, _ISR_Nest_level@ha
     205        lwz             r2, _ISR_Nest_level@l( r6 )
     206       
    191207        /*
    192208         * start decrementing _Thread_Dispatch_disable_level
    193209         */
    194         lwz     r3,_Thread_Dispatch_disable_level@l(r15)
     210        lwz             r3,_Thread_Dispatch_disable_level@l(r15)
    195211        addi    r2, r2, -1      /* Continue decrementing nesting level */
    196212        addi    r3, r3, -1      /* Continue decrementing _Thread_Dispatch_disable_level */
    197         mtspr   SPRG0, r2       /* End decrementing nesting level */
    198         stw     r3,_Thread_Dispatch_disable_level@l(r15) /* End decrementing _Thread_Dispatch_disable_level */
     213       
     214        stw             r2, _ISR_Nest_level@l( r6 )     
     215/*      mtspr   SPRG0, r2 */    /* End decrementing nesting level */
     216       
     217        stw             r3,_Thread_Dispatch_disable_level@l(r15) /* End decrementing _Thread_Dispatch_disable_level */
    199218        cmpwi   r3, 0
    200219        /*
     
    203222         */
    204223        addi    r1, r14, 0
    205         bne     easy_exit /* if (_Thread_Dispatch_disable_level != 0) goto easy_exit */
     224        bne             easy_exit /* if (_Thread_Dispatch_disable_level != 0) goto easy_exit */
    206225        /*
    207226         * Here we are running again on the thread system stack.
     
    211230         */
    212231        addis   r4, 0, _Context_Switch_necessary@ha
    213         lwz     r5, _Context_Switch_necessary@l(r4)
     232        lwz             r5, _Context_Switch_necessary@l(r4)
    214233        cmpwi   r5, 0
    215         bne     switch
     234        bne             switch
    216235       
    217236        addis   r6, 0, _ISR_Signals_to_thread_executing@ha
    218         lwz     r7, _ISR_Signals_to_thread_executing@l(r6)
     237        lwz             r7, _ISR_Signals_to_thread_executing@l(r6)
    219238        cmpwi   r7, 0
    220         li      r8, 0
    221         beq     easy_exit
    222         stw     r8, _ISR_Signals_to_thread_executing@l(r6)
     239        li              r8, 0
     240        beq             easy_exit
     241        stw             r8, _ISR_Signals_to_thread_executing@l(r6)
    223242        /*
    224243         * going to call _ThreadProcessSignalsFromIrq
     
    227246        stmw    r16, GPR16_OFFSET(r1)
    228247        addi    r3, r1, 0x8
    229         /*
    230          * compute SP at exception entry
    231          */
    232         addi    r2, r1, EXCEPTION_FRAME_END
    233         /*
    234          * store it at the right place
    235          */
    236         stw     r2, GPR1_OFFSET(r1)
     248       
     249    /*
     250     * compute SP at exception entry
     251     */
     252    addi    r2, r1, EXCEPTION_FRAME_END
     253    /*
     254     * store it at the right place
     255     */
     256    stw     r2, GPR1_OFFSET(r1)
    237257        /*
    238258         * Call High Level signal handling code
    239259         */
    240         bl      _ThreadProcessSignalsFromIrq
     260        bl              _ThreadProcessSignalsFromIrq
    241261       
    242262
     
    244264         * start restoring exception like frame
    245265         */
    246         lwz     r31,  EXC_CTR_OFFSET(r1)
    247         lwz     r30,  EXC_XER_OFFSET(r1)
    248         lwz     r29,  EXC_CR_OFFSET(r1)
    249         lwz     r28,  EXC_LR_OFFSET(r1)
     266        lwz             r31,  EXC_CTR_OFFSET(r1)
     267        lwz             r30,  EXC_XER_OFFSET(r1)
     268        lwz             r29,  EXC_CR_OFFSET(r1)
     269        lwz             r28,  EXC_LR_OFFSET(r1)
    250270       
    251271        mtctr   r31
     
    255275       
    256276       
    257         lmw     r4, GPR4_OFFSET(r1)
    258 
    259        
    260         lwz     r2, GPR2_OFFSET(r1)
    261         lwz     r0, GPR0_OFFSET(r1)
     277        lmw             r4, GPR4_OFFSET(r1)
     278
     279       
     280        lwz             r2, GPR2_OFFSET(r1)
     281        lwz             r0, GPR0_OFFSET(r1)
    262282
    263283        /*
     
    272292         */
    273293               
    274         lwz     r3, SRR1_FRAME_OFFSET(r1)
     294        lwz             r3, SRR1_FRAME_OFFSET(r1)
    275295        mtsrr1  r3
    276         lwz     r3, SRR0_FRAME_OFFSET(r1)
     296        lwz             r3, SRR0_FRAME_OFFSET(r1)
    277297        mtsrr0  r3
    278298       
    279         lwz     r3, GPR3_OFFSET(r1)
     299        lwz             r3, GPR3_OFFSET(r1)
    280300        addi    r1,r1, EXCEPTION_FRAME_END
    281301        SYNC
     
    283303       
    284304switch:
    285         bl      SYM (_Thread_Dispatch)
     305        bl              SYM (_Thread_Dispatch)
    286306       
    287307easy_exit:     
     
    289309         * start restoring interrupt frame
    290310         */
    291         lwz     r3,  EXC_CTR_OFFSET(r1)
    292         lwz     r4,  EXC_XER_OFFSET(r1)
    293         lwz     r5,  EXC_CR_OFFSET(r1)
    294         lwz     r6,  EXC_LR_OFFSET(r1)
     311        lwz             r3,  EXC_CTR_OFFSET(r1)
     312        lwz             r4,  EXC_XER_OFFSET(r1)
     313        lwz             r5,  EXC_CR_OFFSET(r1)
     314        lwz             r6,  EXC_LR_OFFSET(r1)
    295315       
    296316        mtctr   r3
     
    299319        mtlr    r6
    300320
    301         lwz     r15, GPR15_OFFSET(r1)
    302         lwz     r14, GPR14_OFFSET(r1)
    303         lwz     r13, GPR13_OFFSET(r1)
    304         lwz     r12, GPR12_OFFSET(r1)
    305         lwz     r11, GPR11_OFFSET(r1)
    306         lwz     r10, GPR10_OFFSET(r1)
    307         lwz     r9, GPR9_OFFSET(r1)
    308         lwz     r8, GPR8_OFFSET(r1)
    309         lwz     r7, GPR7_OFFSET(r1)
    310         lwz     r6, GPR6_OFFSET(r1)
    311         lwz     r5, GPR5_OFFSET(r1)
     321        lwz             r15, GPR15_OFFSET(r1)
     322        lwz             r14, GPR14_OFFSET(r1)
     323        lwz             r13, GPR13_OFFSET(r1)
     324        lwz             r12, GPR12_OFFSET(r1)
     325        lwz             r11, GPR11_OFFSET(r1)
     326        lwz             r10, GPR10_OFFSET(r1)
     327        lwz             r9, GPR9_OFFSET(r1)
     328        lwz             r8, GPR8_OFFSET(r1)
     329        lwz             r7, GPR7_OFFSET(r1)
     330        lwz             r6, GPR6_OFFSET(r1)
     331        lwz             r5, GPR5_OFFSET(r1)
    312332
    313333        /*
     
    324344         */
    325345                 
    326         lwz     r4, SRR1_FRAME_OFFSET(r1)
    327         lwz     r2, SRR0_FRAME_OFFSET(r1)
    328         lwz     r3, GPR3_OFFSET(r1)
    329         lwz     r0, GPR0_OFFSET(r1)
     346        lwz             r4, SRR1_FRAME_OFFSET(r1)
     347        lwz             r2, SRR0_FRAME_OFFSET(r1)
     348        lwz             r3, GPR3_OFFSET(r1)
     349        lwz             r0, GPR0_OFFSET(r1)
    330350
    331351        mtsrr1  r4
    332352        mtsrr0  r2
    333         lwz     r4, GPR4_OFFSET(r1)
    334         lwz     r2, GPR2_OFFSET(r1)
     353        lwz             r4, GPR4_OFFSET(r1)
     354        lwz             r2, GPR2_OFFSET(r1)
    335355        addi    r1,r1, EXCEPTION_FRAME_END
    336356        SYNC
  • c/src/lib/libbsp/powerpc/mpc8260ads/irq/irq_init.c

    r7df02840 rd36d3a3  
    4747
    4848static rtems_irq_connect_data           rtemsIrq[BSP_IRQ_NUMBER];
    49 static rtems_irq_global_settings        initial_config;
     49static rtems_irq_global_settings        initial_config;
    5050static rtems_irq_connect_data           defaultIrq = {
    51   /* vectorIdex,         hdl            , on            , off           , isOn */
    52   0,                     nop_func       , nop_func      , nop_func      , not_connected
     51  /* vectorIdex,        hdl                     , on            , off           , isOn */
     52  0,                            nop_func        , nop_func      , nop_func      , not_connected
    5353};
    54 static rtems_irq_prio irqPrioTable[BSP_IRQ_NUMBER]={
     54
     55/*
     56        List the interrupts is their order of priority (highest first).
     57        This does not have to be the same order as the siprr settings but
     58        without knowing more about the application they are kept the same.
     59*/
     60
     61
     62static rtems_irq_prio irqPrioTable[BSP_CPM_IRQ_NUMBER]={
    5563  /*
    5664   * actual priorities for interrupt :
     
    6169  0,  45, 63, 44, 66, 68, 35, 39, 50, 62, 34,  0,  30, 40, 52, 58,
    6270  2,  3,  0,  5,  15, 16, 17, 18, 49, 51,  0,  0,  0,  0,  0,  0,
    63   6,  7,  8,  0,  11, 12, 0,  0,  20, 21, 22, 23,  0,  0,  0,  0,
    64   29, 31, 33, 37, 38, 41, 47, 48, 55, 56, 57, 60, 64, 65, 69, 70,
    65   /*
    66    * Processor exceptions handled as interrupts
    67    */
    68   0
     71  6,  7,  8,  0,  11, 12, 0,  0,  20, 21, 22,  23, 0,  0,  0,  0,
     72  29, 31, 33, 37, 38, 41, 47, 48, 55, 56, 57,  60, 64, 65, 69, 70,
     73
    6974};
    7075
     
    110115     * Init initial Interrupt management config
    111116     */
    112     initial_config.irqNb        = BSP_IRQ_NUMBER;
     117    initial_config.irqNb                = BSP_IRQ_NUMBER;
    113118    initial_config.defaultEntry = defaultIrq;
    114119    initial_config.irqHdlTbl    = rtemsIrq;
    115     initial_config.irqBase      = BSP_ASM_IRQ_VECTOR_BASE;
     120    initial_config.irqBase              = BSP_ASM_IRQ_VECTOR_BASE;
    116121    initial_config.irqPrioTbl   = irqPrioTable;
    117122
     
    131136    vectorDesc.hdl.raw_hdl      =       decrementer_exception_vector_prolog_code;
    132137    vectorDesc.hdl.raw_hdl_size =       (unsigned) &decrementer_exception_vector_prolog_code_size;
    133     vectorDesc.on               =       nop_func;
    134     vectorDesc.off              =       nop_func;
    135     vectorDesc.isOn             =       connected;
     138    vectorDesc.on                       =       nop_func;
     139    vectorDesc.off                      =       nop_func;
     140    vectorDesc.isOn                     =       connected;
    136141    if (!mpc8xx_set_exception (&vectorDesc)) {
    137142      BSP_panic("Unable to initialize RTEMS decrementer raw exception\n");
Note: See TracChangeset for help on using the changeset viewer.