Changeset a35b458 in mainline for kernel/arch/mips32/src


Ignore:
Timestamp:
2018-03-02T20:10:49Z (7 years ago)
Author:
Jiří Zárevúcky <zarevucky.jiri@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
f1380b7
Parents:
3061bc1
git-author:
Jiří Zárevúcky <zarevucky.jiri@…> (2018-02-28 17:38:31)
git-committer:
Jiří Zárevúcky <zarevucky.jiri@…> (2018-03-02 20:10:49)
Message:

style: Remove trailing whitespace on _all_ lines, including empty ones, for particular file types.

Command used: tools/srepl '\s\+$' '' -- *.c *.h *.py *.sh *.s *.S *.ag

Currently, whitespace on empty lines is very inconsistent.
There are two basic choices: Either remove the whitespace, or keep empty lines
indented to the level of surrounding code. The former is AFAICT more common,
and also much easier to do automatically.

Alternatively, we could write script for automatic indentation, and use that
instead. However, if such a script exists, it's possible to use the indented
style locally, by having the editor apply relevant conversions on load/save,
without affecting remote repository. IMO, it makes more sense to adopt
the simpler rule.

Location:
kernel/arch/mips32/src
Files:
10 edited

Legend:

Unmodified
Added
Removed

  • kernel/arch/mips32/src/asm.S

    r3061bc1 ra35b458  
    6262FUNCTION_BEGIN(memcpy_to_uspace)
    6363        move $t2, $a0  /* save dst */
    64        
     64
    6565        addiu $v0, $a1, 3
    6666        li $v1, -4  /* 0xfffffffffffffffc */
    … …  
    6868        beq $a1, $v0, 3f
    6969        move $t0, $a0
    70        
     70
    7171        0:
    7272                beq $a2, $zero, 2f
    7373                move $a3, $zero
    74        
     74
    7575        1:
    7676                addu $v0, $a1, $a3
    … …  
    8080                bne $a3, $a2, 1b
    8181                sb $a0, 0($v1)
    82        
     82
    8383        2:
    8484                jr $ra
    8585                move $v0, $t2
    86        
     86
    8787        3:
    8888                addiu $v0, $a0, 3
    … …  
    9090                bne $a0, $v0, 0b
    9191                srl $t1, $a2, 2
    92                
     92
    9393                beq $t1, $zero, 5f
    9494                move $a3, $zero
    95                
     95
    9696                move $a3, $zero
    9797                move $a0, $zero
    98        
     98
    9999        4:
    100100                addu $v0, $a1, $a0
    … …  
    105105                bne $a3, $t1, 4b
    106106                addiu $a0, $a0, 4
    107        
     107
    108108        5:
    109109                andi $a2, $a2, 0x3
    110110                beq $a2, $zero, 2b
    111111                nop
    112                
     112
    113113                sll $v0, $a3, 2
    114114                addu $t1, $v0, $t0
    115115                move $a3, $zero
    116116                addu $t0, $v0, $a1
    117        
     117
    118118        6:
    119119                addu $v0, $t0, $a3
    … …  
    123123                bne $a3, $a2, 6b
    124124                sb $a0, 0($v1)
    125                
     125
    126126                jr $ra
    127127                move $v0, $t2
    … …  
    188188        fpu_gp_save 30, $a0
    189189        fpu_gp_save 31, $a0
    190        
     190
    191191        fpu_ct_save 1, $a0
    192192        fpu_ct_save 2, $a0
    … …  
    259259        fpu_gp_restore 30, $a0
    260260        fpu_gp_restore 31, $a0
    261        
     261
    262262        fpu_ct_restore 1, $a0
    263263        fpu_ct_restore 2, $a0

  • kernel/arch/mips32/src/context.S

    r3061bc1 ra35b458  
    4747        sw $s8, CONTEXT_OFFSET_S8($a0)
    4848        sw $gp, CONTEXT_OFFSET_GP($a0)
    49        
     49
    5050        sw $ra, CONTEXT_OFFSET_PC($a0)
    5151        sw $sp, CONTEXT_OFFSET_SP($a0)
    52        
     52
    5353        # context_save returns 1
    5454        j $31
    … …  
    6767        lw $s8, CONTEXT_OFFSET_S8($a0)
    6868        lw $gp, CONTEXT_OFFSET_GP($a0)
    69        
     69
    7070        lw $ra, CONTEXT_OFFSET_PC($a0)
    7171        lw $sp, CONTEXT_OFFSET_SP($a0)
    72        
     72
    7373        # context_restore returns 0
    7474        j $31

  • kernel/arch/mips32/src/debug/stacktrace.c

    r3061bc1 ra35b458  
    157157                         * We have a candidate for frame pointer.
    158158                         */
    159                        
     159
    160160                        /* Seek to the end of this function. */
    161161                        for (cur = inst + 1; !IS_JR_RA(*cur); cur++)
    … …  
    170170                        continue;
    171171                }
    172                
     172
    173173                if (IS_JR_RA(*inst)) {
    174174                        if (!ctx->istate)
    … …  
    189189        } while ((!IS_ADDIU_SP_SP_IMM(*inst) && !IS_ADDI_SP_SP_IMM(*inst)) ||
    190190            (IMM_GET(*inst) >= 0));
    191        
     191
    192192        /*
    193193         * We are at the instruction which allocates the space for the current
    … …  
    210210                        if (base == SP || (has_fp && base == fp)) {
    211211                                uint32_t *addr = (void *) (ctx->fp + offset);
    212                                
     212
    213213                                if (offset % 4 != 0)
    214214                                        return false;

  • kernel/arch/mips32/src/debugger.c

    r3061bc1 ra35b458  
    138138{
    139139        unsigned int i;
    140        
     140
    141141        for (i = 0; jmpinstr[i].andmask; i++) {
    142142                if ((instr & jmpinstr[i].andmask) == jmpinstr[i].value)
    143143                        return true;
    144144        }
    145        
     145
    146146        return false;
    147147}
    … …  
    158158                return 1;
    159159        }
    160        
     160
    161161        irq_spinlock_lock(&bkpoint_lock, true);
    162        
     162
    163163        /* Check, that the breakpoints do not conflict */
    164164        unsigned int i;
    … …  
    176176                        return 0;
    177177                }
    178                
    179         }
    180        
     178
     179        }
     180
    181181        bpinfo_t *cur = NULL;
    182        
     182
    183183        for (i = 0; i < BKPOINTS_MAX; i++) {
    184184                if (!breakpoints[i].address) {
    … …  
    187187                }
    188188        }
    189        
     189
    190190        if (!cur) {
    191191                printf("Too many breakpoints.\n");
    … …  
    193193                return 0;
    194194        }
    195        
     195
    196196        printf("Adding breakpoint on address %p\n", (void *) argv->intval);
    197        
     197
    198198        cur->address = (uintptr_t) argv->intval;
    199199        cur->instruction = ((sysarg_t *) cur->address)[0];
    … …  
    205205                cur->bkfunc = (void (*)(void *, istate_t *)) argv[1].intval;
    206206        }
    207        
     207
    208208        if (is_jump(cur->instruction))
    209209                cur->flags |= BKPOINT_ONESHOT;
    210        
     210
    211211        cur->counter = 0;
    212        
     212
    213213        /* Set breakpoint */
    214214        *((sysarg_t *) cur->address) = 0x0d;
    215215        smc_coherence(cur->address);
    216        
     216
    217217        irq_spinlock_unlock(&bkpoint_lock, true);
    218        
     218
    219219        return 1;
    220220}
    … …  
    229229                return 0;
    230230        }
    231        
     231
    232232        irq_spinlock_lock(&bkpoint_lock, true);
    233        
     233
    234234        bpinfo_t *cur = &breakpoints[argv->intval];
    235235        if (!cur->address) {
    … …  
    238238                return 0;
    239239        }
    240        
     240
    241241        if ((cur->flags & BKPOINT_INPROG) && (cur->flags & BKPOINT_ONESHOT)) {
    242242                printf("Cannot remove one-shot breakpoint in-progress\n");
    … …  
    244244                return 0;
    245245        }
    246        
     246
    247247        ((uint32_t *) cur->address)[0] = cur->instruction;
    248248        smc_coherence(((uint32_t *) cur->address)[0]);
    249249        ((uint32_t *) cur->address)[1] = cur->nextinstruction;
    250250        smc_coherence(((uint32_t *) cur->address)[1]);
    251        
     251
    252252        cur->address = (uintptr_t) NULL;
    253        
     253
    254254        irq_spinlock_unlock(&bkpoint_lock, true);
    255255        return 1;
    … …  
    262262{
    263263        unsigned int i;
    264        
     264
    265265        printf("[nr] [count] [address ] [inprog] [oneshot] [funccall] [in symbol\n");
    266        
     266
    267267        for (i = 0; i < BKPOINTS_MAX; i++) {
    268268                if (breakpoints[i].address) {
    269269                        const char *symbol = symtab_fmt_name_lookup(
    270270                            breakpoints[i].address);
    271                        
     271
    272272                        printf("%-4u %7zu %p %-8s %-9s %-10s %s\n", i,
    273273                            breakpoints[i].counter, (void *) breakpoints[i].address,
    … …  
    278278                }
    279279        }
    280        
     280
    281281        return 1;
    282282}
    … …  
    290290{
    291291        unsigned int i;
    292        
     292
    293293        for (i = 0; i < BKPOINTS_MAX; i++)
    294294                breakpoints[i].address = (uintptr_t) NULL;
    295        
     295
    296296#ifdef CONFIG_KCONSOLE
    297297        cmd_initialize(&bkpts_info);
    … …  
    299299                log(LF_OTHER, LVL_WARN, "Cannot register command %s",
    300300                    bkpts_info.name);
    301        
     301
    302302        cmd_initialize(&delbkpt_info);
    303303        if (!cmd_register(&delbkpt_info))
    304304                log(LF_OTHER, LVL_WARN, "Cannot register command %s",
    305305                    delbkpt_info.name);
    306        
     306
    307307        cmd_initialize(&addbkpt_info);
    308308        if (!cmd_register(&addbkpt_info))
    309309                log(LF_OTHER, LVL_WARN, "Cannot register command %s",
    310310                    addbkpt_info.name);
    311        
     311
    312312        cmd_initialize(&addbkpte_info);
    313313        if (!cmd_register(&addbkpte_info))
    … …  
    331331        if (cp0_cause_read() & 0x80000000)
    332332                panic("Breakpoint in branch delay slot not supported.");
    333        
     333
    334334        irq_spinlock_lock(&bkpoint_lock, false);
    335        
     335
    336336        bpinfo_t *cur = NULL;
    337337        uintptr_t fireaddr = istate->epc;
    338338        unsigned int i;
    339        
     339
    340340        for (i = 0; i < BKPOINTS_MAX; i++) {
    341341                /* Normal breakpoint */
    … …  
    345345                        break;
    346346                }
    347                
     347
    348348                /* Reinst only breakpoint */
    349349                if ((breakpoints[i].flags & BKPOINT_REINST) &&
    … …  
    353353                }
    354354        }
    355        
     355
    356356        if (cur) {
    357357                if (cur->flags & BKPOINT_REINST) {
    … …  
    359359                        ((uint32_t *) cur->address)[0] = 0x0d;
    360360                        smc_coherence(((uint32_t *)cur->address)[0]);
    361                        
     361
    362362                        /* Return back the second */
    363363                        ((uint32_t *) cur->address)[1] = cur->nextinstruction;
    364364                        smc_coherence(((uint32_t *) cur->address)[1]);
    365                        
     365
    366366                        cur->flags &= ~BKPOINT_REINST;
    367367                        irq_spinlock_unlock(&bkpoint_lock, false);
    368368                        return;
    369369                }
    370                
     370
    371371                if (cur->flags & BKPOINT_INPROG)
    372372                        printf("Warning: breakpoint recursion\n");
    373                
     373
    374374                if (!(cur->flags & BKPOINT_FUNCCALL)) {
    375375                        printf("***Breakpoint %u: %p in %s.\n", i,
    … …  
    377377                            symtab_fmt_name_lookup(fireaddr));
    378378                }
    379                
     379
    380380                /* Return first instruction back */
    381381                ((uint32_t *)cur->address)[0] = cur->instruction;
    … …  
    392392                    (void *) fireaddr,
    393393                    symtab_fmt_name_lookup(fireaddr));
    394                
     394
    395395                /* Move on to next instruction */
    396396                istate->epc += 4;
    397397        }
    398        
     398
    399399        if (cur)
    400400                cur->counter++;
    401        
     401
    402402        if (cur && (cur->flags & BKPOINT_FUNCCALL)) {
    403403                /* Allow zero bkfunc, just for counting */
    … …  
    414414                atomic_set(&haltstate, 1);
    415415                irq_spinlock_unlock(&bkpoint_lock, false);
    416                
     416
    417417                kconsole("debug", "Debug console ready.\n", false);
    418                
     418
    419419                irq_spinlock_lock(&bkpoint_lock, false);
    420420                atomic_set(&haltstate, 0);
    421421#endif
    422422        }
    423        
     423
    424424        if ((cur) && (cur->address == fireaddr)
    425425            && ((cur->flags & BKPOINT_INPROG))) {
    … …  
    427427                if ((cur->flags & BKPOINT_ONESHOT))
    428428                        cur->address = (uintptr_t) NULL;
    429                
     429
    430430                /* Remove in-progress flag */
    431431                cur->flags &= ~BKPOINT_INPROG;
    432432        }
    433        
     433
    434434        irq_spinlock_unlock(&bkpoint_lock, false);
    435435}

  • kernel/arch/mips32/src/exception.c

    r3061bc1 ra35b458  
    7777            "lo =%#010" PRIx32 "\thi =%#010" PRIx32 "\n",
    7878            istate->epc, istate->status, istate->lo, istate->hi);
    79        
     79
    8080        log_printf("a0 =%#010" PRIx32 "\ta1 =%#010" PRIx32 "\t"
    8181            "a2 =%#010" PRIx32 "\ta3 =%#010" PRIx32 "\n",
    8282            istate->a0, istate->a1, istate->a2, istate->a3);
    83        
     83
    8484        log_printf("t0 =%#010" PRIx32 "\tt1 =%#010" PRIx32 "\t"
    8585            "t2 =%#010" PRIx32 "\tt3 =%#010" PRIx32 "\n",
    8686            istate->t0, istate->t1, istate->t2, istate->t3);
    87        
     87
    8888        log_printf("t4 =%#010" PRIx32 "\tt5 =%#010" PRIx32 "\t"
    8989            "t6 =%#010" PRIx32 "\tt7 =%#010" PRIx32 "\n",
    9090            istate->t4, istate->t5, istate->t6, istate->t7);
    91        
     91
    9292        log_printf("t8 =%#010" PRIx32 "\tt9 =%#010" PRIx32 "\t"
    9393            "v0 =%#010" PRIx32 "\tv1 =%#010" PRIx32 "\n",
    9494            istate->t8, istate->t9, istate->v0, istate->v1);
    95        
     95
    9696        log_printf("s0 =%#010" PRIx32 "\ts1 =%#010" PRIx32 "\t"
    9797            "s2 =%#010" PRIx32 "\ts3 =%#010" PRIx32 "\n",
    9898            istate->s0, istate->s1, istate->s2, istate->s3);
    99        
     99
    100100        log_printf("s4 =%#010" PRIx32 "\ts5 =%#010" PRIx32 "\t"
    101101            "s6 =%#010" PRIx32 "\ts7 =%#010" PRIx32 "\n",
    102102            istate->s4, istate->s5, istate->s6, istate->s7);
    103        
     103
    104104        log_printf("s8 =%#010" PRIx32 "\tat =%#010" PRIx32 "\t"
    105105            "kt0=%#010" PRIx32 "\tkt1=%#010" PRIx32 "\n",
    106106            istate->s8, istate->at, istate->kt0, istate->kt1);
    107        
     107
    108108        log_printf("sp =%#010" PRIx32 "\tra =%#010" PRIx32 "\t"
    109109            "gp =%#010" PRIx32 "\n",
    … …  
    171171        ip = (cp0_cause_read() & cp0_cause_ip_mask) >> cp0_cause_ip_shift;
    172172        im = (cp0_status_read() & cp0_status_im_mask) >> cp0_status_im_shift;
    173        
     173
    174174        unsigned int i;
    175175        for (i = 0; i < 8; i++) {
    … …  
    212212{
    213213        unsigned int i;
    214        
     214
    215215        /* Clear exception table */
    216216        for (i = 0; i < IVT_ITEMS; i++)
    217217                exc_register(i, "undef", false,
    218218                    (iroutine_t) unhandled_exception);
    219        
     219
    220220        exc_register(EXC_Bp, "bkpoint", true,
    221221            (iroutine_t) breakpoint_exception);
    … …  
    230230        exc_register(EXC_Int, "interrupt", true,
    231231            (iroutine_t) interrupt_exception);
    232        
     232
    233233#ifdef CONFIG_FPU_LAZY
    234234        exc_register(EXC_CpU, "cpunus", true,
    235235            (iroutine_t) cpuns_exception);
    236236#endif
    237        
     237
    238238        exc_register(EXC_Sys, "syscall", true,
    239239            (iroutine_t) syscall_exception);

  • kernel/arch/mips32/src/interrupt.c

    r3061bc1 ra35b458  
    132132                /* Count overflow detected */
    133133                count_hi++;
    134        
     134
    135135        lastcount = cp0_count_read();
    136        
     136
    137137        unsigned long drift = cp0_count_read() - nextcount;
    138138        while (drift > cp0_compare_value) {
    … …  
    140140                CPU->missed_clock_ticks++;
    141141        }
    142        
     142
    143143        nextcount = cp0_count_read() + cp0_compare_value - drift;
    144144        cp0_compare_write(nextcount);
    145        
     145
    146146        /*
    147147         * We are holding a lock which prevents preemption.
    … …  
    151151        clock();
    152152        irq_spinlock_lock(&irq->lock, false);
    153        
     153
    154154        if (virtual_timer_fnc != NULL)
    155155                virtual_timer_fnc();
    … …  
    172172{
    173173        irq_init(IRQ_COUNT, IRQ_COUNT);
    174        
     174
    175175        irq_initialize(&timer_irq);
    176176        timer_irq.inr = TIMER_IRQ;
    … …  
    178178        timer_irq.handler = timer_irq_handler;
    179179        irq_register(&timer_irq);
    180        
     180
    181181        timer_start();
    182182        cp0_unmask_int(TIMER_IRQ);
    183        
     183
    184184#ifdef MACHINE_msim
    185185        irq_initialize(&dorder_irq);
    … …  
    188188        dorder_irq.handler = dorder_irq_handler;
    189189        irq_register(&dorder_irq);
    190        
     190
    191191        cp0_unmask_int(DORDER_IRQ);
    192192#endif

  • kernel/arch/mips32/src/mips32.c

    r3061bc1 ra35b458  
    8686{
    8787        init.cnt = min3(bootinfo->cnt, TASKMAP_MAX_RECORDS, CONFIG_INIT_TASKS);
    88        
     88
    8989        size_t i;
    9090        for (i = 0; i < init.cnt; i++) {
    … …  
    9494                    bootinfo->tasks[i].name);
    9595        }
    96        
     96
    9797        for (i = 0; i < CPUMAP_MAX_RECORDS; i++) {
    9898                if ((bootinfo->cpumap & (1 << i)) != 0)
    … …  
    112112        /* It is not assumed by default */
    113113        interrupts_disable();
    114        
     114
    115115        /* Initialize dispatch table */
    116116        exception_init();
    … …  
    123123        memcpy(CACHE_EXC, (char *) cache_error_entry, EXCEPTION_JUMP_SIZE);
    124124        smc_coherence_block(CACHE_EXC, EXCEPTION_JUMP_SIZE);
    125        
     125
    126126        /*
    127127         * Switch to BEV normal level so that exception vectors point to the
    … …  
    130130        cp0_status_write(cp0_status_read() &
    131131            ~(cp0_status_bev_bootstrap_bit | cp0_status_erl_error_bit));
    132        
     132
    133133        /*
    134134         * Mask all interrupts
    135135         */
    136136        cp0_mask_all_int();
    137        
     137
    138138        debugger_init();
    139139}
    … …  
    171171            (uintptr_t) kernel_uarg->uspace_uarg,
    172172            (uintptr_t) kernel_uarg->uspace_entry);
    173        
     173
    174174        while (1);
    175175}

  • kernel/arch/mips32/src/mm/frame.c

    r3061bc1 ra35b458  
    8282        if (frame == (KA2PA(MSIM_VIDEORAM) >> ZERO_PAGE_WIDTH))
    8383                return false;
    84        
     84
    8585        /* MSIM device (dkeyboard) */
    8686        if (frame == (KA2PA(MSIM_KBD_ADDRESS) >> ZERO_PAGE_WIDTH))
    … …  
    9292                return false;
    9393#endif
    94        
     94
    9595        return true;
    9696}
    … …  
    108108        if ((frame << ZERO_PAGE_WIDTH) < KA2PA(config.base))
    109109                return false;
    110        
     110
    111111        /* Kernel */
    112112        if (overlaps(frame << ZERO_PAGE_WIDTH, ZERO_PAGE_SIZE,
    113113            KA2PA(config.base), config.kernel_size))
    114114                return false;
    115        
     115
    116116        /* Kernel stack */
    117117        if (overlaps(frame << ZERO_PAGE_WIDTH, ZERO_PAGE_SIZE,
    118118            KA2PA(config.stack_base), config.stack_size))
    119119                return false;
    120        
     120
    121121        /* Init tasks */
    122122        bool safe = true;
    … …  
    128128                        break;
    129129                }
    130        
     130
    131131        return safe;
    132132}
    … …  
    161161                            ZONE_AVAILABLE | ZONE_HIGHMEM);
    162162        }
    163        
     163
    164164        if (phys_regions_count < MAX_REGIONS) {
    165165                phys_regions[phys_regions_count].start = first;
    … …  
    182182{
    183183        ipl_t ipl = interrupts_disable();
    184        
     184
    185185        /* Clear and initialize TLB */
    186186        cp0_pagemask_write(ZERO_PAGE_MASK);
    … …  
    194194                tlbwi();
    195195        }
    196                
     196
    197197        pfn_t start_frame = 0;
    198198        pfn_t frame;
    199199        bool avail = true;
    200        
     200
    201201        /* Walk through all 1 MB frames */
    202202        for (frame = 0; frame < ZERO_FRAMES; frame++) {
    … …  
    211211                                tlb_prepare_entry_lo(&lo1, false, false, false, false, 0);
    212212                                tlb_prepare_entry_hi(&hi, ZERO_PAGE_ASID, ZERO_PAGE_ADDR);
    213                                
     213
    214214                                cp0_pagemask_write(ZERO_PAGE_MASK);
    215215                                cp0_entry_lo0_write(lo0.value);
    … …  
    218218                                cp0_index_write(ZERO_PAGE_TLBI);
    219219                                tlbwi();
    220                                
     220
    221221                                ZERO_PAGE_VALUE = 0;
    222222                                if (ZERO_PAGE_VALUE != 0)
    … …  
    229229                        }
    230230                }
    231                
     231
    232232                if (!avail) {
    233233                        frame_add_region(start_frame, frame, true);
    … …  
    236236                }
    237237        }
    238        
     238
    239239        frame_add_region(start_frame, frame, true);
    240        
     240
    241241        /* Blacklist interrupt vector frame */
    242242        frame_mark_unavailable(0, 1);
    … …  
    267267        frame_mark_unavailable(0, 1024 * 1024 / FRAME_SIZE);
    268268#endif
    269        
     269
    270270        /* Cleanup */
    271271        cp0_pagemask_write(ZERO_PAGE_MASK);
    … …  
    275275        cp0_index_write(ZERO_PAGE_TLBI);
    276276        tlbwi();
    277        
     277
    278278        interrupts_restore(ipl);
    279279}
    … …  
    286286{
    287287        printf("[base    ] [size    ]\n");
    288        
     288
    289289        size_t i;
    290290        for (i = 0; i < phys_regions_count; i++) {

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

    r3061bc1 ra35b458  
    7676
    7777        /* Clear and initialize TLB. */
    78        
     78
    7979        for (i = 0; i < TLB_ENTRY_COUNT; i++) {
    8080                cp0_index_write(i);
    8181                tlbwi();
    8282        }
    83        
     83
    8484        /*
    8585         * The kernel is going to make use of some wired
    … …  
    9898        uintptr_t badvaddr;
    9999        pte_t pte;
    100        
     100
    101101        badvaddr = cp0_badvaddr_read();
    102102
    … …  
    291291        lo1_save.value = cp0_entry_lo1_read();
    292292        mask_save.value = cp0_pagemask_read();
    293        
     293
    294294        printf("[nr] [asid] [vpn2    ] [mask] [gvdc] [pfn     ]\n");
    295        
     295
    296296        for (i = 0; i < TLB_ENTRY_COUNT; i++) {
    297297                cp0_index_write(i);
    298298                tlbr();
    299                
     299
    300300                mask.value = cp0_pagemask_read();
    301301                hi.value = cp0_entry_hi_read();
    302302                lo0.value = cp0_entry_lo0_read();
    303303                lo1.value = cp0_entry_lo1_read();
    304                
     304
    305305                printf("%-4u %-6u %0#10x %-#6x  %1u%1u%1u%1u  %0#10x\n",
    306306                    i, hi.asid, HI_VPN22ADDR(hi.vpn2), mask.mask,
    … …  
    309309                    lo1.g, lo1.v, lo1.d, lo1.c, LO_PFN2ADDR(lo1.pfn));
    310310        }
    311        
     311
    312312        cp0_entry_hi_write(hi_save.value);
    313313        cp0_entry_lo0_write(lo0_save.value);
    … …  
    339339                cp0_entry_lo0_write(lo0.value);
    340340                cp0_entry_lo1_write(lo1.value);
    341                                
     341
    342342                tlbwi();
    343343        }
    344        
     344
    345345        cp0_entry_hi_write(hi_save.value);
    346346}
    … …  
    360360
    361361        hi_save.value = cp0_entry_hi_read();
    362        
     362
    363363        for (i = 0; i < TLB_ENTRY_COUNT; i++) {
    364364                cp0_index_write(i);
    365365                tlbr();
    366                
     366
    367367                hi.value = cp0_entry_hi_read();
    368                
     368
    369369                if (hi.asid == asid) {
    370370                        lo0.value = cp0_entry_lo0_read();
    … …  
    380380                }
    381381        }
    382        
     382
    383383        cp0_entry_hi_write(hi_save.value);
    384384}
    … …  
    399399
    400400        assert(interrupts_disabled());
    401        
     401
    402402        if (asid == ASID_INVALID)
    403403                return;
    … …  
    431431                }
    432432        }
    433        
     433
    434434        cp0_entry_hi_write(hi_save.value);
    435435}

  • kernel/arch/mips32/src/start.S

    r3061bc1 ra35b458  
    8989        sw $s7, ISTATE_OFFSET_S7(\r)
    9090        sw $s8, ISTATE_OFFSET_S8(\r)
    91        
     91
    9292        mflo $at
    9393        sw $at, ISTATE_OFFSET_LO(\r)
    9494        mfhi $at
    9595        sw $at, ISTATE_OFFSET_HI(\r)
    96        
     96
    9797        sw $gp, ISTATE_OFFSET_GP(\r)
    9898        sw $ra, ISTATE_OFFSET_RA(\r)
    9999        sw $k0, ISTATE_OFFSET_KT0(\r)
    100100        sw $k1, ISTATE_OFFSET_KT1(\r)
    101        
     101
    102102        mfc0 $t0, $status
    103103        mfc0 $t1, $epc
    104        
     104
    105105        /* save only KSU, EXL, ERL, IE */
    106106        and $t2, $t0, REG_SAVE_MASK
    107        
     107
    108108        /* clear KSU, EXL, ERL, IE */
    109109        li $t3, ~(REG_SAVE_MASK)
    110110        and $t0, $t0, $t3
    111        
     111
    112112        sw $t2, ISTATE_OFFSET_STATUS(\r)
    113113        sw $t1, ISTATE_OFFSET_EPC(\r)
    … …  
    122122        mfc0 $t0, $status
    123123        lw $t1, ISTATE_OFFSET_STATUS(\r)
    124        
     124
    125125        /* mask UM, EXL, ERL, IE */
    126126        li $t2, ~REG_SAVE_MASK
    127127        and $t0, $t0, $t2
    128        
     128
    129129        /* copy UM, EXL, ERL, IE from saved status */
    130130        or $t0, $t0, $t1
    131131        mtc0 $t0, $status
    132        
     132
    133133        lw $v0, ISTATE_OFFSET_V0(\r)
    134134        lw $v1, ISTATE_OFFSET_V1(\r)
    … …  
    147147        lw $t8, ISTATE_OFFSET_T8(\r)
    148148        lw $t9, ISTATE_OFFSET_T9(\r)
    149        
     149
    150150        lw $gp, ISTATE_OFFSET_GP(\r)
    151151        lw $ra, ISTATE_OFFSET_RA(\r)
    152152        lw $k1, ISTATE_OFFSET_KT1(\r)
    153        
     153
    154154        lw $at, ISTATE_OFFSET_LO(\r)
    155155        mtlo $at
    156156        lw $at, ISTATE_OFFSET_HI(\r)
    157157        mthi $at
    158        
     158
    159159        lw $at, ISTATE_OFFSET_EPC(\r)
    160160        mtc0 $at, $epc
    161        
     161
    162162        lw $at, ISTATE_OFFSET_AT(\r)
    163163        lw $sp, ISTATE_OFFSET_SP(\r)
    … …  
    172172        mfc0 $k0, $status
    173173        andi $k0, 0x10
    174        
     174
    175175        beq $k0, $0, 1f
    176176        move $k0, $sp
    177        
     177
    178178        /* move $k0 pointer to kernel stack */
    179179        la $k0, supervisor_sp
    180        
     180
    181181        /* move $k0 (supervisor_sp) */
    182182        lw $k0, ($k0)
    183        
     183
    184184        1:
    185185.endm
    … …  
    190190        lui $sp, %hi(end_stack)
    191191        ori $sp, $sp, %lo(end_stack)
    192        
     192
    193193        /* not sure about this, but might be needed for PIC code */
    194194        lui $gp, 0x8000
    195        
     195
    196196        /* $a1 contains physical address of bootinfo_t */
    197197        jal mips32_pre_main
    198198        addiu $sp, -ABI_STACK_FRAME
    199        
     199
    200200        j main_bsp
    201201        nop
    … …  
    219219exception_handler:
    220220        KERNEL_STACK_TO_K0
    221        
     221
    222222        sub $k0, ISTATE_SIZE
    223223        sw $sp, ISTATE_OFFSET_SP($k0)
    224224        move $sp, $k0
    225        
     225
    226226        mfc0 $k0, $cause
    227        
     227
    228228        sra $k0, $k0, 0x2    /* cp0_exc_cause() part 1 */
    229229        andi $k0, $k0, 0x1f  /* cp0_exc_cause() part 2 */
    230230        sub $k0, 8           /* 8 = SYSCALL */
    231        
     231
    232232        beqz $k0, syscall_shortcut
    233233        add $k0, 8           /* revert $k0 back to correct exc number */
    234        
     234
    235235        REGISTERS_STORE_AND_EXC_RESET $sp
    236        
     236
    237237        move $a1, $sp
    238238        move $a0, $k0
    … …  
    240240        addiu $sp, -ABI_STACK_FRAME
    241241        addiu $sp, ABI_STACK_FRAME
    242        
     242
    243243        REGISTERS_LOAD $sp
    244244        /* the $sp is automatically restored to former value */
    … …  
    265265        sw $t3, ISTATE_OFFSET_EPC($sp)  /* save EPC */
    266266        sw $k1, ISTATE_OFFSET_KT1($sp)  /* save $k1 not saved on context switch */
    267        
     267
    268268        and $t4, $t2, REG_SAVE_MASK  /* save only KSU, EXL, ERL, IE */
    269269        li $t5, ~(0x1f)
    270270        and $t2, $t2, $t5  /* clear KSU, EXL, ERL */
    271271        ori $t2, $t2, 0x1  /* set IE */
    272        
     272
    273273        sw $t4, ISTATE_OFFSET_STATUS($sp)
    274274        mtc0 $t2, $status
    275        
     275
    276276        /*
    277277         * Call the higher level system call handler.
    … …  
    280280        sw $t0, ISTATE_OFFSET_T0($sp)  /* save the 5th argument on the stack */
    281281        sw $t1, ISTATE_OFFSET_T1($sp)  /* save the 6th argument on the stack */
    282        
     282
    283283        jal syscall_handler
    284284        sw $v0, ISTATE_OFFSET_V0($sp)  /* save the syscall number on the stack */
    285        
     285
    286286        /* restore status */
    287287        mfc0 $t2, $status
    288288        lw $t3, ISTATE_OFFSET_STATUS($sp)
    289        
     289
    290290        /*
    291291         * Change back to EXL = 1 (from last exception), otherwise
    … …  
    297297        or $t2, $t2, $t3  /* copy saved UM, EXL, ERL, IE */
    298298        mtc0 $t2, $status
    299        
     299
    300300        /* restore epc + 4 */
    301301        lw $t2, ISTATE_OFFSET_EPC($sp)
    … …  
    303303        addi $t2, $t2, 4
    304304        mtc0 $t2, $epc
    305        
     305
    306306        lw $sp, ISTATE_OFFSET_SP($sp)  /* restore $sp */
    307307        eret
    … …  
    314314        sw $sp, ISTATE_OFFSET_SP($k0)
    315315        move $sp, $k0
    316        
     316
    317317        move $a0, $sp
    318318        jal tlb_refill
    319319        addiu $sp, -ABI_STACK_FRAME
    320320        addiu $sp, ABI_STACK_FRAME
    321        
     321
    322322        REGISTERS_LOAD $sp
    323323        eret
    … …  
    330330        sw $sp, ISTATE_OFFSET_SP($k0)
    331331        move $sp, $k0
    332        
     332
    333333        move $a0, $sp
    334334        jal cache_error
    335335        addiu $sp, -ABI_STACK_FRAME
    336336        addiu $sp, ABI_STACK_FRAME
    337        
     337
    338338        REGISTERS_LOAD $sp
    339339        eret
Note: See TracChangeset for help on using the changeset viewer.