Changeset 464ba4d in rtems


Ignore:
Timestamp:
Dec 5, 2007, 9:29:03 AM (13 years ago)
Author:
Till Straumann <strauman@…>
Branches:
4.10, 4.11, 4.9, master
Children:
1fd33fb4
Parents:
698c3362
Message:

2007-12-05 Till Straumann <strauman@…>

  • new-exceptions/raw_exception.c, new-exceptions/raw_exception.h: Added typedef for exception classes (classic, critical, ... synchronous / asynchronous). ppc_vector_is_valid() now returns the appropriate class.
Location:
c/src/lib/libcpu/powerpc
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • c/src/lib/libcpu/powerpc/ChangeLog

    r698c3362 r464ba4d  
     12007-12-05      Till Straumann <strauman@slac.stanford.edu>
     2
     3        * new-exceptions/raw_exception.c, new-exceptions/raw_exception.h:
     4        Added typedef for exception classes (classic, critical, ...
     5        synchronous / asynchronous). ppc_vector_is_valid() now returns
     6        the appropriate class.
     7
    182007-12-05      Till Straumann <strauman@slac.stanford.edu>
    29
  • c/src/lib/libcpu/powerpc/new-exceptions/raw_exception.c

    r698c3362 r464ba4d  
    9898#if ( defined(mpc860) || defined(mpc821) || defined(__ppc_generic) )
    9999
    100 static int mpc860_vector_is_valid(rtems_vector vector)
     100static ppc_raw_exception_category mpc860_vector_is_valid(rtems_vector vector)
    101101{
    102102  switch(vector) {
     
    125125  case ASM_8XX_PERIFBREAK_VECTOR:
    126126  case ASM_8XX_DEVPORT_VECTOR:
    127     return 1;
    128   default: return 0;
     127    return PPC_EXC_CLASSIC;
     128  default: return PPC_EXC_INVALID;
    129129  }
    130130}
     
    133133#if (defined(mpc555) || defined(mpc505) || defined(__ppc_generic))
    134134
    135 static int mpc5xx_vector_is_valid(rtems_vector vector)
     135static ppc_raw_exception_category mpc5xx_vector_is_valid(rtems_vector vector)
    136136{
    137137  switch (current_ppc_cpu) {
     
    160160        case ASM_5XX_MEBREAK_VECTOR:
    161161        case ASM_5XX_NMEBREAK_VECTOR:
    162           return 1;
     162          return PPC_EXC_CLASSIC;
    163163        default:
    164           return 0;
     164          return PPC_EXC_INVALID;
    165165      }
    166166    default:
    167167      printk("Please complete libcpu/powerpc/shared/new-exceptions/raw_exception.c\n");
    168168      printk("current_ppc_cpu = %x\n", current_ppc_cpu);
    169       return 0;
     169      return PPC_EXC_INVALID;
    170170  }
    171171}
     
    173173
    174174#if ( defined(ppc405) || defined(__ppc_generic) )
    175 static int ppc405_vector_is_valid(rtems_vector vector)
    176 
    177 {
    178   switch(vector) {
    179   case ASM_RESET_VECTOR: /* fall through */
    180   case ASM_MACH_VECTOR:
     175static ppc_raw_exception_category ppc405_vector_is_valid(rtems_vector vector)
     176
     177{
     178ppc_raw_exception_category rval = PPC_EXC_INVALID;
     179  switch(vector) {
     180  case ASM_EXT_VECTOR:
     181  case ASM_BOOKE_PIT_VECTOR:
     182
     183        rval |= PPC_EXC_ASYNC;
     184
     185        /* fall through */
    181186  case ASM_PROT_VECTOR:
    182187  case ASM_ISI_VECTOR:
    183   case ASM_EXT_VECTOR:
    184188  case ASM_ALIGN_VECTOR:
    185189  case ASM_PROG_VECTOR:
    186190  case ASM_SYS_VECTOR:
    187   case ASM_BOOKE_PIT_VECTOR:
    188191  case ASM_BOOKE_ITLBMISS_VECTOR:
    189192  case ASM_BOOKE_DTLBMISS_VECTOR:
    190     return 1;
    191   default: return 0;
     193
     194        return rval | PPC_EXC_CLASSIC;
     195
     196  case ASM_RESET_VECTOR: /* fall through */
     197        rval |= PPC_EXC_ASYNC;
     198  case ASM_MACH_VECTOR:
     199    return rval | PPC_EXC_405_CRITICAL;
     200  default: return PPC_EXC_INVALID;
    192201  }
    193202}
     
    196205#if defined(PPC_HAS_60X_VECTORS) /* 60x style cpu types */
    197206
    198 static int altivec_vector_is_valid(rtems_vector vector)
     207static ppc_raw_exception_category altivec_vector_is_valid(rtems_vector vector)
    199208{
    200209        if ( ppc_cpu_has_altivec() ) {
     
    202211                        case ASM_60X_VEC_VECTOR:
    203212                        case ASM_60X_VEC_ASSIST_VECTOR:
    204                                 return 1;
     213                                return PPC_EXC_CLASSIC;
    205214                        default:
    206215                                break;
    207216                }
    208217        }
    209   return 0;
    210 }
    211 
    212 static int mpc750_vector_is_valid(rtems_vector vector)
     218  return PPC_EXC_INVALID;
     219}
     220
     221static ppc_raw_exception_category mpc750_vector_is_valid(rtems_vector vector)
    213222
    214223{
     
    228237  case ASM_60X_SYSMGMT_VECTOR:
    229238  case ASM_60X_ITM_VECTOR:
    230     return 1;
    231   default: return 0;
    232   }
    233 }
    234 
    235 static int PSIM_vector_is_valid(rtems_vector vector)
     239    return PPC_EXC_CLASSIC;
     240  default: return PPC_EXC_INVALID;
     241  }
     242}
     243
     244static ppc_raw_exception_category PSIM_vector_is_valid(rtems_vector vector)
    236245{
    237246  switch(vector) {
     
    245254  case ASM_FLOAT_VECTOR:
    246255  case ASM_DEC_VECTOR:
    247     return 1;
     256    return PPC_EXC_CLASSIC;
    248257  case ASM_SYS_VECTOR:
    249     return 0;
     258    return PPC_EXC_INVALID;
    250259  case ASM_TRACE_VECTOR:
    251     return 1;
     260    return PPC_EXC_CLASSIC;
    252261  case ASM_60X_PERFMON_VECTOR:
    253     return 0;
     262    return PPC_EXC_INVALID;
    254263  case ASM_60X_IMISS_VECTOR: /* fall through */
    255264  case ASM_60X_DLMISS_VECTOR:
     
    257266  case ASM_60X_ADDR_VECTOR:
    258267  case ASM_60X_SYSMGMT_VECTOR:
    259     return 1;
     268    return PPC_EXC_CLASSIC;
    260269  case ASM_60X_ITM_VECTOR:
    261     return 0;
    262   }
    263   return 0;
    264 }
    265 
    266 static int mpc603_vector_is_valid(rtems_vector vector)
     270    return PPC_EXC_INVALID;
     271  }
     272  return PPC_EXC_INVALID;
     273}
     274
     275static ppc_raw_exception_category mpc603_vector_is_valid(rtems_vector vector)
    267276{
    268277  switch(vector) {
     
    278287  case ASM_SYS_VECTOR:
    279288  case ASM_TRACE_VECTOR:
    280     return 1;
     289    return PPC_EXC_CLASSIC;
    281290  case ASM_60X_PERFMON_VECTOR:
    282     return 0;
     291    return PPC_EXC_INVALID;
    283292  case ASM_60X_IMISS_VECTOR: /* fall through */
    284293  case ASM_60X_DLMISS_VECTOR:
     
    286295  case ASM_60X_ADDR_VECTOR:
    287296  case ASM_60X_SYSMGMT_VECTOR:
    288     return 1;
     297    return PPC_EXC_CLASSIC;
    289298  case ASM_60X_ITM_VECTOR:
    290     return 0;
    291   }
    292   return 0;
    293 }
    294 
    295 static int mpc604_vector_is_valid(rtems_vector vector)
     299    return PPC_EXC_INVALID;
     300  }
     301  return PPC_EXC_INVALID;
     302}
     303
     304static ppc_raw_exception_category mpc604_vector_is_valid(rtems_vector vector)
    296305{
    297306  switch(vector) {
     
    308317  case ASM_TRACE_VECTOR:
    309318  case ASM_60X_PERFMON_VECTOR:
    310     return 1;
     319    return PPC_EXC_CLASSIC;
    311320  case ASM_60X_IMISS_VECTOR: /* fall through */
    312321  case ASM_60X_DLMISS_VECTOR:
    313322  case ASM_60X_DSMISS_VECTOR:
    314     return 0;
     323    return PPC_EXC_INVALID;
    315324  case ASM_60X_ADDR_VECTOR: /* fall through */
    316325  case ASM_60X_SYSMGMT_VECTOR:
    317     return 1;
     326    return PPC_EXC_CLASSIC;
    318327  case ASM_60X_ITM_VECTOR:
    319     return 0;
    320   }
    321   return 0;
    322 }
    323 
    324 static int e500_vector_is_valid(rtems_vector vector)
    325 {
     328    return PPC_EXC_INVALID;
     329  }
     330  return PPC_EXC_INVALID;
     331}
     332
     333static ppc_raw_exception_category e500_vector_is_valid(rtems_vector vector)
     334{
     335ppc_raw_exception_category rval = PPC_EXC_INVALID;
     336
    326337        switch (vector) {
    327         case ASM_RESET_VECTOR:
    328338        case ASM_MACH_VECTOR:
     339                return PPC_EXC_E500_MACHCHK;
     340
     341        case ASM_BOOKE_CRIT_VECTOR:
     342        case ASM_BOOKE_WDOG_VECTOR:
     343                rval |= PPC_EXC_ASYNC;
     344                /* fall thru */
     345        case ASM_TRACE_VECTOR:
     346                return rval | PPC_EXC_BOOKE_CRITICAL;
     347
     348        case ASM_EXT_VECTOR:
     349        case ASM_DEC_VECTOR:
     350        case ASM_BOOKE_FIT_VECTOR:
     351                rval |= PPC_EXC_ASYNC;
     352
     353                /* fall thru */
     354
    329355        case ASM_PROT_VECTOR:
    330356        case ASM_ISI_VECTOR:
    331         case ASM_EXT_VECTOR:
    332357        case ASM_ALIGN_VECTOR:
    333358        case ASM_PROG_VECTOR:
     
    335360        case ASM_SYS_VECTOR:
    336361        case /* APU unavailable      */ 0x0b:
    337         case ASM_DEC_VECTOR:
     362
    338363        case ASM_60X_DLMISS_VECTOR:
    339364        case ASM_60X_DSMISS_VECTOR:
    340         case ASM_TRACE_VECTOR:
    341365        case ASM_60X_VEC_VECTOR:
    342366        case ASM_60X_PERFMON_VECTOR:
    343367
    344         case 0x13 /*ASM_BOOKE_FIT_VECTOR*/:
    345         case 0x14 /*ASM_BOOKE_WDOG_VECTOR*/:
    346368        case /* emb FP data          */ 0x15:
    347369        case /* emb FP round         */ 0x16:
    348                 return 1;
     370                return rval | PPC_EXC_CLASSIC;
    349371        default:
    350372                break;
    351373        }
    352         return 0;
     374        return PPC_EXC_INVALID;
    353375}
    354376
    355377#endif /* 60x style cpu types */
    356378
    357 int ppc_vector_is_valid(rtems_vector vector)
    358 {
     379ppc_raw_exception_category ppc_vector_is_valid(rtems_vector vector)
     380{
     381ppc_raw_exception_category rval = PPC_EXC_INVALID;
     382
    359383     switch (current_ppc_cpu) {
    360384#if defined(PPC_HAS_60X_VECTORS)
    361385        case PPC_7400:
    362             if ( altivec_vector_is_valid(vector) )
    363                 return 1;
     386            if ( ( rval = altivec_vector_is_valid(vector)) )
     387                return rval;
    364388            /* else fall thru */
    365389        case PPC_750:
    366             if (!mpc750_vector_is_valid(vector)) {
    367                 return 0;
    368             }
     390            rval = mpc750_vector_is_valid(vector);
    369391            break;
    370392        case PPC_7455:   /* Kate Feng */
    371393        case PPC_7457:
    372             if ( altivec_vector_is_valid(vector) )
    373                 return 1;
     394            if ( ( rval = altivec_vector_is_valid(vector) ) )
     395                return rval;
    374396            /* else fall thru */
    375397        case PPC_604:
    376398        case PPC_604e:
    377399        case PPC_604r:
    378             if (!mpc604_vector_is_valid(vector)) {
    379                 return 0;
    380             }
     400            rval = mpc604_vector_is_valid(vector);
    381401            break;
    382402        case PPC_603:
     
    390410        case PPC_e300c2:
    391411        case PPC_e300c3:
    392             if (!mpc603_vector_is_valid(vector)) {
    393                 return 0;
    394             }
     412            rval = mpc603_vector_is_valid(vector);
    395413            break;
    396414        case PPC_PSIM:
    397             if (!PSIM_vector_is_valid(vector)) {
    398                 return 0;
    399             }
     415            rval = PSIM_vector_is_valid(vector);
    400416            break;
    401417                case PPC_8540:
    402                         if ( !e500_vector_is_valid(vector) ) {
    403                                 return 0;
    404                         }
     418                        rval = e500_vector_is_valid(vector);
    405419                        break;
    406420#endif
    407421#if ( defined(mpc555) || defined(mpc505) || defined(__ppc_generic) )
    408422        case PPC_5XX:
    409             if (!mpc5xx_vector_is_valid(vector)) {
    410                 return 0;
    411             }
     423            rval = mpc5xx_vector_is_valid(vector);
    412424            break;
    413425#endif
    414426#if ( defined(mpc860) || defined(mpc821) || defined(__ppc_generic) )
    415427        case PPC_860:
    416             if (!mpc860_vector_is_valid(vector)) {
    417                 return 0;
    418             }
     428            rval = mpc860_vector_is_valid(vector);
    419429            break;
    420430#endif
    421431#if ( defined(ppc405) || defined(__ppc_generic) )
    422432        case PPC_405:
    423             if (!ppc405_vector_is_valid(vector)) {
    424                 return 0;
    425             }
     433            rval = ppc405_vector_is_valid(vector);
    426434            break;
    427435#endif
     
    430438                   "libcpu/powerpc/new-exceptions/raw_exception.c\n"
    431439                   "current_ppc_cpu = %x\n", current_ppc_cpu);
    432             return 0;
     440            return PPC_EXC_INVALID;
    433441     }
    434      return 1;
     442         /* set ASYNC flag for all CPU flavors EE and DEC */
     443         if ( ASM_EXT_VECTOR == rval || ASM_DEC_VECTOR == rval ) {
     444                rval |= PPC_EXC_ASYNC;
     445         }
     446     return rval;
    435447}
    436448
     
    439451    rtems_interrupt_level k;
    440452
    441     if (!ppc_vector_is_valid(except->hdl.vector)) {
     453    if ( PPC_EXC_INVALID == ppc_vector_is_valid(except->hdl.vector) ) {
    442454      printk("ppc_set_exception: vector %d is not valid\n",
    443455              except->hdl.vector);
     
    478490        int i;
    479491
    480         if (!ppc_vector_is_valid(except->hdl.vector)){
     492        if ( PPC_EXC_INVALID == ppc_vector_is_valid(except->hdl.vector) ) {
    481493                return 0;
    482494        }
     
    501513  rtems_interrupt_level k;
    502514
    503   if (!ppc_vector_is_valid(except->hdl.vector)){
     515  if ( PPC_EXC_INVALID == ppc_vector_is_valid(except->hdl.vector) ) {
    504516    return 0;
    505517  }
     
    557569
    558570        for (i=0; i < config->exceptSize; i++) {
    559                 if (!ppc_vector_is_valid(raw_except_table[i].hdl.vector)){
     571                if ( PPC_EXC_INVALID == ppc_vector_is_valid(raw_except_table[i].hdl.vector) ) {
    560572                        continue;
    561573                }
  • c/src/lib/libcpu/powerpc/new-exceptions/raw_exception.h

    r698c3362 r464ba4d  
    360360
    361361/*
     362 * Exceptions of different categories use different SRR registers
     363 * to save machine state (:-()
     364 */
     365typedef enum {
     366        PPC_EXC_INVALID        = 0,
     367        PPC_EXC_CLASSIC        = 1,
     368        PPC_EXC_405_CRITICAL   = 2,
     369        PPC_EXC_BOOKE_CRITICAL = 3,
     370        PPC_EXC_E500_MACHCHK   = 4,
     371        PPC_EXC_ASYNC          = 0x10000,
     372} ppc_raw_exception_category;
     373
     374/*
    362375 * C callable function enabling to set up one raw idt entry
    363376 */
     
    376389/*
    377390 * C callable function enabling to check if vector is valid
    378  */
    379 extern int ppc_vector_is_valid(rtems_vector vector);
     391 * and returns category.
     392 */
     393extern ppc_raw_exception_category ppc_vector_is_valid(rtems_vector vector);
    380394
    381395/*
Note: See TracChangeset for help on using the changeset viewer.