Changeset 25d7709 in mainline for arch/mips32/src


Ignore:
Timestamp:
2006-03-13T20:08:16Z (20 years ago)
Author:
Jakub Jermar <jakub@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
631ca4d
Parents:
45d6add
Message:

Nicer ia32 interrupt handlers and structures holding interrupted context data.
Unify the name holding interrupted context data on all architectures to be istate.

Location:
arch/mips32/src
Files:
8 edited

Legend:

Unmodified
Added
Removed

  • arch/mips32/src/debugger.c

    r45d6add r25d7709  
    180180        } else { /* We are add extended */
    181181                cur->flags = BKPOINT_FUNCCALL;
    182                 cur->bkfunc =   (void (*)(void *, struct exception_regdump *)) argv[1].intval;
     182                cur->bkfunc =   (void (*)(void *, istate_t *)) argv[1].intval;
    183183        }
    184184        if (is_jump(cur->instruction))
    … …  
    290290 * next instruction.
    291291 */
    292 void debugger_bpoint(struct exception_regdump *pstate)
     292void debugger_bpoint(istate_t *istate)
    293293{
    294294        bpinfo_t *cur = NULL;
    295         __address fireaddr = pstate->epc;
     295        __address fireaddr = istate->epc;
    296296        int i;
    297297
    … …  
    330330                if (!(cur->flags & BKPOINT_FUNCCALL))
    331331                        printf("***Breakpoint %d: 0x%p in %s.\n", i,
    332                                fireaddr, get_symtab_entry(pstate->epc));
     332                               fireaddr, get_symtab_entry(istate->epc));
    333333
    334334                /* Return first instruction back */
    … …  
    345345                       get_symtab_entry(fireaddr));
    346346                /* Move on to next instruction */
    347                 pstate->epc += 4;
     347                istate->epc += 4;
    348348        }
    349349        if (cur)
    … …  
    352352                /* Allow zero bkfunc, just for counting */
    353353                if (cur->bkfunc)
    354                         cur->bkfunc(cur, pstate);
     354                        cur->bkfunc(cur, istate);
    355355        } else {
    356356                printf("***Type 'exit' to exit kconsole.\n");

  • arch/mips32/src/drivers/arc.c

    r45d6add r25d7709  
    350350iroutine old_timer;
    351351/** Do polling on timer interrupt */
    352 static void timer_replace(int n, void *stack)
     352static void timer_replace(int n, istate_t *istate)
    353353{
    354354        arc_keyboard_poll();
    355         old_timer(n, stack);
     355        old_timer(n, istate);
    356356        arc_keyboard_poll();
    357357}

  • arch/mips32/src/drivers/msim.c

    r45d6add r25d7709  
    8484
    8585/** Process keyboard interrupt. */
    86 static void msim_interrupt(int n, void *stack)
     86static void msim_interrupt(int n, istate_t *istate)
    8787{
    8888        char ch = 0;

  • arch/mips32/src/drivers/serial.c

    r45d6add r25d7709  
    113113iroutine old_timer;
    114114/** Do polling on timer interrupt */
    115 static void timer_replace(int n, void *stack)
     115static void timer_replace(int n, istate_t *istate)
    116116{
    117         old_timer(n, stack);
    118         serial_interrupt(n, stack);
     117        old_timer(n, istate);
     118        serial_interrupt(n, istate);
    119119}
    120120

  • arch/mips32/src/exception.c

    r45d6add r25d7709  
    6363};
    6464
    65 static void print_regdump(struct exception_regdump *pstate)
     65static void print_regdump(istate_t *istate)
    6666{
    6767        char *pcsymbol = "";
    6868        char *rasymbol = "";
    6969
    70         char *s = get_symtab_entry(pstate->epc);
     70        char *s = get_symtab_entry(istate->epc);
    7171        if (s)
    7272                pcsymbol = s;
    73         s = get_symtab_entry(pstate->ra);
     73        s = get_symtab_entry(istate->ra);
    7474        if (s)
    7575                rasymbol = s;
    7676       
    77         printf("PC: %X(%s) RA: %X(%s), SP(%P)\n",pstate->epc,pcsymbol,
    78                pstate->ra,rasymbol, pstate->sp);
    79 }
    80 
    81 static void unhandled_exception(int n, struct exception_regdump *pstate)
    82 {
    83         print_regdump(pstate);
     77        printf("PC: %X(%s) RA: %X(%s), SP(%P)\n",istate->epc,pcsymbol,
     78               istate->ra,rasymbol, istate->sp);
     79}
     80
     81static void unhandled_exception(int n, istate_t *istate)
     82{
     83        print_regdump(istate);
    8484        panic("unhandled exception %s\n", exctable[n]);
    8585}
    8686
    87 static void breakpoint_exception(int n, struct exception_regdump *pstate)
     87static void breakpoint_exception(int n, istate_t *istate)
    8888{
    8989#ifdef CONFIG_DEBUG
    90         debugger_bpoint(pstate);
     90        debugger_bpoint(istate);
    9191#else
    9292        /* it is necessary to not re-execute BREAK instruction after
    9393           returning from Exception handler
    9494           (see page 138 in R4000 Manual for more information) */
    95         pstate->epc += 4;
     95        istate->epc += 4;
    9696#endif
    9797}
    9898
    99 static void tlbmod_exception(int n, struct exception_regdump *pstate)
    100 {
    101         tlb_modified(pstate);
    102 }
    103 
    104 static void tlbinv_exception(int n, struct exception_regdump *pstate)
    105 {
    106         tlb_invalid(pstate);
     99static void tlbmod_exception(int n, istate_t *istate)
     100{
     101        tlb_modified(istate);
     102}
     103
     104static void tlbinv_exception(int n, istate_t *istate)
     105{
     106        tlb_invalid(istate);
    107107}
    108108
    109109#ifdef CONFIG_FPU_LAZY
    110 static void cpuns_exception(int n, struct exception_regdump *pstate)
     110static void cpuns_exception(int n, istate_t *istate)
    111111{
    112112        if (cp0_cause_coperr(cp0_cause_read()) == fpu_cop_id)
    … …  
    117117#endif
    118118
    119 static void interrupt_exception(int n, struct exception_regdump *pstate)
     119static void interrupt_exception(int n, istate_t *istate)
    120120{
    121121        __u32 cause;
    … …  
    127127        for (i = 0; i < 8; i++)
    128128                if (cause & (1 << i))
    129                         exc_dispatch(i+INT_OFFSET, pstate);
     129                        exc_dispatch(i+INT_OFFSET, istate);
    130130}
    131131
    132132#include <debug.h>
    133133/** Handle syscall userspace call */
    134 static void syscall_exception(int n, struct exception_regdump *pstate)
     134static void syscall_exception(int n, istate_t *istate)
    135135{
    136136        interrupts_enable();
    137         if (pstate->a3 < SYSCALL_END)
    138                 pstate->v0 = syscall_table[pstate->a3](pstate->a0,
    139                                                        pstate->a1,
    140                                                        pstate->a2);
     137        if (istate->a3 < SYSCALL_END)
     138                istate->v0 = syscall_table[istate->a3](istate->a0,
     139                                                       istate->a1,
     140                                                       istate->a2);
    141141        else
    142                 panic("Undefined syscall %d", pstate->a3);
     142                panic("Undefined syscall %d", istate->a3);
     143        istate->epc += 4;
    143144        interrupts_disable();
    144         pstate->epc += 4;
    145 }
    146 
    147 
    148 void exception(struct exception_regdump *pstate)
     145}
     146
     147void exception(istate_t *istate)
    149148{
    150149        int cause;
    … …  
    164163                                                cp0_status_um_bit));
    165164
    166         /* Save pstate so that the threads can access it */
    167         /* If THREAD->pstate is set, this is nested exception,
     165        /* Save istate so that the threads can access it */
     166        /* If THREAD->istate is set, this is nested exception,
    168167         * do not rewrite it
    169168         */
    170         if (THREAD && !THREAD->pstate)
    171                 THREAD->pstate = pstate;
     169        if (THREAD && !THREAD->istate)
     170                THREAD->istate = istate;
    172171
    173172        cause = cp0_cause_read();
    174173        excno = cp0_cause_excno(cause);
    175174        /* Dispatch exception */
    176         exc_dispatch(excno, pstate);
     175        exc_dispatch(excno, istate);
    177176
    178177        /* Set to NULL, so that we can still support nested
    … …  
    180179         * TODO: We should probably set EXL bit before this command,
    181180         * nesting. On the other hand, if some exception occurs between
    182          * here and ERET, it won't set anything on the pstate anyway.
     181         * here and ERET, it won't set anything on the istate anyway.
    183182         */
    184183        if (THREAD)
    185                 THREAD->pstate = NULL;
     184                THREAD->istate = NULL;
    186185}
    187186

  • arch/mips32/src/fpu_context.c

    r45d6add r25d7709  
    3737#ifdef ARCH_HAS_FPU
    3838        cp0_status_write(cp0_status_read() & ~cp0_status_fpu_bit);
    39         if (THREAD && THREAD->pstate)
    40                 THREAD->pstate->status &= ~cp0_status_fpu_bit;
     39        if (THREAD && THREAD->istate)
     40                THREAD->istate->status &= ~cp0_status_fpu_bit;
    4141#endif
    4242}
    … …  
    4646#ifdef ARCH_HAS_FPU
    4747        cp0_status_write(cp0_status_read() | cp0_status_fpu_bit);
    48         if (THREAD && THREAD->pstate)
    49                 THREAD->pstate->status |= cp0_status_fpu_bit;
     48        if (THREAD && THREAD->istate)
     49                THREAD->istate->status |= cp0_status_fpu_bit;
    5050#endif
    5151}

  • arch/mips32/src/interrupt.c

    r45d6add r25d7709  
    7575}
    7676
    77 static void timer_exception(int n, void *stack)
     77static void timer_exception(int n, istate_t *istate)
    7878{
    7979        cp0_compare_write(cp0_count_read() + cp0_compare_value);
    … …  
    8181}
    8282
    83 static void swint0(int n, void *stack)
     83static void swint0(int n, istate_t *istate)
    8484{
    8585        cp0_cause_write(cp0_cause_read() & ~(1 << 8)); /* clear SW0 interrupt */
    8686}
    8787
    88 static void swint1(int n, void *stack)
     88static void swint1(int n, istate_t *istate)
    8989{
    9090        cp0_cause_write(cp0_cause_read() & ~(1 << 9)); /* clear SW1 interrupt */

  • arch/mips32/src/mm/tlb.c

    r45d6add r25d7709  
    4040#include <debug.h>
    4141
    42 static void tlb_refill_fail(struct exception_regdump *pstate);
    43 static void tlb_invalid_fail(struct exception_regdump *pstate);
    44 static void tlb_modified_fail(struct exception_regdump *pstate);
     42static void tlb_refill_fail(istate_t *istate);
     43static void tlb_invalid_fail(istate_t *istate);
     44static void tlb_modified_fail(istate_t *istate);
    4545
    4646static pte_t *find_mapping_and_check(__address badvaddr);
    … …  
    8282 * Process TLB Refill Exception.
    8383 *
    84  * @param pstate Interrupted register context.
    85  */
    86 void tlb_refill(struct exception_regdump *pstate)
     84 * @param istate Interrupted register context.
     85 */
     86void tlb_refill(istate_t *istate)
    8787{
    8888        entry_lo_t lo;
    … …  
    127127fail:
    128128        spinlock_unlock(&AS->lock);
    129         tlb_refill_fail(pstate);
     129        tlb_refill_fail(istate);
    130130}
    131131
    … …  
    134134 * Process TLB Invalid Exception.
    135135 *
    136  * @param pstate Interrupted register context.
    137  */
    138 void tlb_invalid(struct exception_regdump *pstate)
     136 * @param istate Interrupted register context.
     137 */
     138void tlb_invalid(istate_t *istate)
    139139{
    140140        tlb_index_t index;
    … …  
    196196fail:
    197197        spinlock_unlock(&AS->lock);
    198         tlb_invalid_fail(pstate);
     198        tlb_invalid_fail(istate);
    199199}
    200200
    … …  
    203203 * Process TLB Modified Exception.
    204204 *
    205  * @param pstate Interrupted register context.
    206  */
    207 void tlb_modified(struct exception_regdump *pstate)
     205 * @param istate Interrupted register context.
     206 */
     207void tlb_modified(istate_t *istate)
    208208{
    209209        tlb_index_t index;
    … …  
    272272fail:
    273273        spinlock_unlock(&AS->lock);
    274         tlb_modified_fail(pstate);
    275 }
    276 
    277 void tlb_refill_fail(struct exception_regdump *pstate)
     274        tlb_modified_fail(istate);
     275}
     276
     277void tlb_refill_fail(istate_t *istate)
    278278{
    279279        char *symbol = "";
    280280        char *sym2 = "";
    281281
    282         char *s = get_symtab_entry(pstate->epc);
     282        char *s = get_symtab_entry(istate->epc);
    283283        if (s)
    284284                symbol = s;
    285         s = get_symtab_entry(pstate->ra);
     285        s = get_symtab_entry(istate->ra);
    286286        if (s)
    287287                sym2 = s;
    288         panic("%X: TLB Refill Exception at %X(%s<-%s)\n", cp0_badvaddr_read(), pstate->epc, symbol, sym2);
    289 }
    290 
    291 
    292 void tlb_invalid_fail(struct exception_regdump *pstate)
     288        panic("%X: TLB Refill Exception at %X(%s<-%s)\n", cp0_badvaddr_read(), istate->epc, symbol, sym2);
     289}
     290
     291
     292void tlb_invalid_fail(istate_t *istate)
    293293{
    294294        char *symbol = "";
    295295
    296         char *s = get_symtab_entry(pstate->epc);
     296        char *s = get_symtab_entry(istate->epc);
    297297        if (s)
    298298                symbol = s;
    299         panic("%X: TLB Invalid Exception at %X(%s)\n", cp0_badvaddr_read(), pstate->epc, symbol);
    300 }
    301 
    302 void tlb_modified_fail(struct exception_regdump *pstate)
     299        panic("%X: TLB Invalid Exception at %X(%s)\n", cp0_badvaddr_read(), istate->epc, symbol);
     300}
     301
     302void tlb_modified_fail(istate_t *istate)
    303303{
    304304        char *symbol = "";
    305305
    306         char *s = get_symtab_entry(pstate->epc);
     306        char *s = get_symtab_entry(istate->epc);
    307307        if (s)
    308308                symbol = s;
    309         panic("%X: TLB Modified Exception at %X(%s)\n", cp0_badvaddr_read(), pstate->epc, symbol);
     309        panic("%X: TLB Modified Exception at %X(%s)\n", cp0_badvaddr_read(), istate->epc, symbol);
    310310}
    311311
Note: See TracChangeset for help on using the changeset viewer.