Subversion Repositories HelenOS

Rev

Rev 3228 | Rev 4153 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
1 jermar 1
/*
2071 jermar 2
 * Copyright (c) 2003-2004 Jakub Jermar
1 jermar 3
 * All rights reserved.
4
 *
5
 * Redistribution and use in source and binary forms, with or without
6
 * modification, are permitted provided that the following conditions
7
 * are met:
8
 *
9
 * - Redistributions of source code must retain the above copyright
10
 *   notice, this list of conditions and the following disclaimer.
11
 * - Redistributions in binary form must reproduce the above copyright
12
 *   notice, this list of conditions and the following disclaimer in the
13
 *   documentation and/or other materials provided with the distribution.
14
 * - The name of the author may not be used to endorse or promote products
15
 *   derived from this software without specific prior written permission.
16
 *
17
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
18
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27
 */
28
 
1776 jermar 29
/** @addtogroup mips32mm   
1702 cejka 30
 * @{
31
 */
32
/** @file
33
 */
34
 
1 jermar 35
#include <arch/mm/tlb.h>
727 jermar 36
#include <mm/asid.h>
1 jermar 37
#include <mm/tlb.h>
391 jermar 38
#include <mm/page.h>
703 jermar 39
#include <mm/as.h>
1 jermar 40
#include <arch/cp0.h>
41
#include <panic.h>
42
#include <arch.h>
268 palkovsky 43
#include <symtab.h>
391 jermar 44
#include <synch/spinlock.h>
45
#include <print.h>
396 jermar 46
#include <debug.h>
983 palkovsky 47
#include <align.h>
1595 palkovsky 48
#include <interrupt.h>
268 palkovsky 49
 
958 jermar 50
static void tlb_refill_fail(istate_t *istate);
51
static void tlb_invalid_fail(istate_t *istate);
52
static void tlb_modified_fail(istate_t *istate);
391 jermar 53
 
1780 jermar 54
static pte_t *find_mapping_and_check(uintptr_t badvaddr, int access, istate_t *istate, int *pfrc);
399 jermar 55
 
391 jermar 56
/** Initialize TLB
57
 *
58
 * Initialize TLB.
59
 * Invalidate all entries and mark wired entries.
60
 */
569 jermar 61
void tlb_arch_init(void)
389 jermar 62
{
599 jermar 63
    int i;
64
 
389 jermar 65
    cp0_pagemask_write(TLB_PAGE_MASK_16K);
599 jermar 66
    cp0_entry_hi_write(0);
67
    cp0_entry_lo0_write(0);
68
    cp0_entry_lo1_write(0);
389 jermar 69
 
599 jermar 70
    /* Clear and initialize TLB. */
71
 
72
    for (i = 0; i < TLB_ENTRY_COUNT; i++) {
73
        cp0_index_write(i);
74
        tlbwi();
75
    }
598 jermar 76
 
389 jermar 77
    /*
78
     * The kernel is going to make use of some wired
391 jermar 79
     * entries (e.g. mapping kernel stacks in kseg3).
389 jermar 80
     */
81
    cp0_wired_write(TLB_WIRED);
82
}
83
 
391 jermar 84
/** Process TLB Refill Exception
85
 *
86
 * Process TLB Refill Exception.
87
 *
958 jermar 88
 * @param istate Interrupted register context.
391 jermar 89
 */
958 jermar 90
void tlb_refill(istate_t *istate)
1 jermar 91
{
396 jermar 92
    entry_lo_t lo;
1044 jermar 93
    entry_hi_t hi;
94
    asid_t asid;
1780 jermar 95
    uintptr_t badvaddr;
391 jermar 96
    pte_t *pte;
1288 jermar 97
    int pfrc;
397 jermar 98
 
391 jermar 99
    badvaddr = cp0_badvaddr_read();
397 jermar 100
 
1044 jermar 101
    spinlock_lock(&AS->lock);
102
    asid = AS->asid;
103
    spinlock_unlock(&AS->lock);
399 jermar 104
 
1044 jermar 105
    page_table_lock(AS, true);
106
 
1411 jermar 107
    pte = find_mapping_and_check(badvaddr, PF_ACCESS_READ, istate, &pfrc);
1288 jermar 108
    if (!pte) {
109
        switch (pfrc) {
110
        case AS_PF_FAULT:
111
            goto fail;
112
            break;
113
        case AS_PF_DEFER:
114
            /*
115
             * The page fault came during copy_from_uspace()
116
             * or copy_to_uspace().
117
             */
118
            page_table_unlock(AS, true);
119
            return;
120
        default:
121
            panic("unexpected pfrc (%d)\n", pfrc);
122
        }
123
    }
391 jermar 124
 
125
    /*
394 jermar 126
     * Record access to PTE.
391 jermar 127
     */
394 jermar 128
    pte->a = 1;
391 jermar 129
 
3228 decky 130
    tlb_prepare_entry_hi(&hi, asid, badvaddr);
131
    tlb_prepare_entry_lo(&lo, pte->g, pte->p, pte->d, pte->cacheable, pte->pfn);
394 jermar 132
 
391 jermar 133
    /*
134
     * New entry is to be inserted into TLB
135
     */
399 jermar 136
    cp0_entry_hi_write(hi.value);
391 jermar 137
    if ((badvaddr/PAGE_SIZE) % 2 == 0) {
396 jermar 138
        cp0_entry_lo0_write(lo.value);
391 jermar 139
        cp0_entry_lo1_write(0);
140
    }
141
    else {
142
        cp0_entry_lo0_write(0);
396 jermar 143
        cp0_entry_lo1_write(lo.value);
391 jermar 144
    }
612 jermar 145
    cp0_pagemask_write(TLB_PAGE_MASK_16K);
391 jermar 146
    tlbwr();
147
 
1044 jermar 148
    page_table_unlock(AS, true);
391 jermar 149
    return;
150
 
151
fail:
1044 jermar 152
    page_table_unlock(AS, true);
958 jermar 153
    tlb_refill_fail(istate);
391 jermar 154
}
155
 
394 jermar 156
/** Process TLB Invalid Exception
157
 *
158
 * Process TLB Invalid Exception.
159
 *
958 jermar 160
 * @param istate Interrupted register context.
394 jermar 161
 */
958 jermar 162
void tlb_invalid(istate_t *istate)
391 jermar 163
{
396 jermar 164
    tlb_index_t index;
1780 jermar 165
    uintptr_t badvaddr;
396 jermar 166
    entry_lo_t lo;
399 jermar 167
    entry_hi_t hi;
394 jermar 168
    pte_t *pte;
1288 jermar 169
    int pfrc;
394 jermar 170
 
171
    badvaddr = cp0_badvaddr_read();
172
 
173
    /*
174
     * Locate the faulting entry in TLB.
175
     */
399 jermar 176
    hi.value = cp0_entry_hi_read();
3228 decky 177
    tlb_prepare_entry_hi(&hi, hi.asid, badvaddr);
399 jermar 178
    cp0_entry_hi_write(hi.value);
394 jermar 179
    tlbp();
396 jermar 180
    index.value = cp0_index_read();
1044 jermar 181
 
182
    page_table_lock(AS, true); 
394 jermar 183
 
184
    /*
185
     * Fail if the entry is not in TLB.
186
     */
396 jermar 187
    if (index.p) {
188
        printf("TLB entry not found.\n");
394 jermar 189
        goto fail;
396 jermar 190
    }
394 jermar 191
 
1411 jermar 192
    pte = find_mapping_and_check(badvaddr, PF_ACCESS_READ, istate, &pfrc);
1288 jermar 193
    if (!pte) {
194
        switch (pfrc) {
195
        case AS_PF_FAULT:
196
            goto fail;
197
            break;
198
        case AS_PF_DEFER:
199
            /*
200
             * The page fault came during copy_from_uspace()
201
             * or copy_to_uspace().
202
             */
203
            page_table_unlock(AS, true);             
204
            return;
205
        default:
206
            panic("unexpected pfrc (%d)\n", pfrc);
207
        }
208
    }
394 jermar 209
 
210
    /*
211
     * Read the faulting TLB entry.
212
     */
213
    tlbr();
214
 
215
    /*
216
     * Record access to PTE.
217
     */
218
    pte->a = 1;
219
 
3228 decky 220
    tlb_prepare_entry_lo(&lo, pte->g, pte->p, pte->d, pte->cacheable, pte->pfn);
394 jermar 221
 
222
    /*
223
     * The entry is to be updated in TLB.
224
     */
225
    if ((badvaddr/PAGE_SIZE) % 2 == 0)
396 jermar 226
        cp0_entry_lo0_write(lo.value);
394 jermar 227
    else
396 jermar 228
        cp0_entry_lo1_write(lo.value);
612 jermar 229
    cp0_pagemask_write(TLB_PAGE_MASK_16K);
394 jermar 230
    tlbwi();
231
 
1044 jermar 232
    page_table_unlock(AS, true);
394 jermar 233
    return;
234
 
235
fail:
1044 jermar 236
    page_table_unlock(AS, true);
958 jermar 237
    tlb_invalid_fail(istate);
391 jermar 238
}
239
 
394 jermar 240
/** Process TLB Modified Exception
241
 *
242
 * Process TLB Modified Exception.
243
 *
958 jermar 244
 * @param istate Interrupted register context.
394 jermar 245
 */
958 jermar 246
void tlb_modified(istate_t *istate)
391 jermar 247
{
396 jermar 248
    tlb_index_t index;
1780 jermar 249
    uintptr_t badvaddr;
396 jermar 250
    entry_lo_t lo;
399 jermar 251
    entry_hi_t hi;
394 jermar 252
    pte_t *pte;
1288 jermar 253
    int pfrc;
394 jermar 254
 
255
    badvaddr = cp0_badvaddr_read();
256
 
257
    /*
258
     * Locate the faulting entry in TLB.
259
     */
399 jermar 260
    hi.value = cp0_entry_hi_read();
3228 decky 261
    tlb_prepare_entry_hi(&hi, hi.asid, badvaddr);
399 jermar 262
    cp0_entry_hi_write(hi.value);
394 jermar 263
    tlbp();
396 jermar 264
    index.value = cp0_index_read();
1044 jermar 265
 
266
    page_table_lock(AS, true); 
394 jermar 267
 
268
    /*
269
     * Fail if the entry is not in TLB.
270
     */
396 jermar 271
    if (index.p) {
272
        printf("TLB entry not found.\n");
394 jermar 273
        goto fail;
396 jermar 274
    }
394 jermar 275
 
1411 jermar 276
    pte = find_mapping_and_check(badvaddr, PF_ACCESS_WRITE, istate, &pfrc);
1288 jermar 277
    if (!pte) {
278
        switch (pfrc) {
279
        case AS_PF_FAULT:
280
            goto fail;
281
            break;
282
        case AS_PF_DEFER:
283
            /*
284
             * The page fault came during copy_from_uspace()
285
             * or copy_to_uspace().
286
             */
287
            page_table_unlock(AS, true);             
288
            return;
289
        default:
290
            panic("unexpected pfrc (%d)\n", pfrc);
291
        }
292
    }
394 jermar 293
 
294
    /*
295
     * Fail if the page is not writable.
296
     */
297
    if (!pte->w)
298
        goto fail;
299
 
300
    /*
301
     * Read the faulting TLB entry.
302
     */
303
    tlbr();
304
 
305
    /*
306
     * Record access and write to PTE.
307
     */
308
    pte->a = 1;
831 jermar 309
    pte->d = 1;
394 jermar 310
 
3228 decky 311
    tlb_prepare_entry_lo(&lo, pte->g, pte->p, pte->w, pte->cacheable, pte->pfn);
394 jermar 312
 
313
    /*
314
     * The entry is to be updated in TLB.
315
     */
316
    if ((badvaddr/PAGE_SIZE) % 2 == 0)
396 jermar 317
        cp0_entry_lo0_write(lo.value);
394 jermar 318
    else
396 jermar 319
        cp0_entry_lo1_write(lo.value);
612 jermar 320
    cp0_pagemask_write(TLB_PAGE_MASK_16K);
394 jermar 321
    tlbwi();
322
 
1044 jermar 323
    page_table_unlock(AS, true);
394 jermar 324
    return;
325
 
326
fail:
1044 jermar 327
    page_table_unlock(AS, true);
958 jermar 328
    tlb_modified_fail(istate);
391 jermar 329
}
330
 
958 jermar 331
void tlb_refill_fail(istate_t *istate)
391 jermar 332
{
324 palkovsky 333
    char *symbol = "";
334
    char *sym2 = "";
335
 
958 jermar 336
    char *s = get_symtab_entry(istate->epc);
332 palkovsky 337
    if (s)
338
        symbol = s;
958 jermar 339
    s = get_symtab_entry(istate->ra);
332 palkovsky 340
    if (s)
341
        sym2 = s;
1595 palkovsky 342
 
1735 decky 343
    fault_if_from_uspace(istate, "TLB Refill Exception on %p", cp0_badvaddr_read());
344
    panic("%x: TLB Refill Exception at %x(%s<-%s)\n", cp0_badvaddr_read(), istate->epc, symbol, sym2);
1 jermar 345
}
346
 
391 jermar 347
 
958 jermar 348
void tlb_invalid_fail(istate_t *istate)
1 jermar 349
{
268 palkovsky 350
    char *symbol = "";
351
 
958 jermar 352
    char *s = get_symtab_entry(istate->epc);
332 palkovsky 353
    if (s)
354
        symbol = s;
1735 decky 355
    fault_if_from_uspace(istate, "TLB Invalid Exception on %p", cp0_badvaddr_read());
356
    panic("%x: TLB Invalid Exception at %x(%s)\n", cp0_badvaddr_read(), istate->epc, symbol);
1 jermar 357
}
358
 
958 jermar 359
void tlb_modified_fail(istate_t *istate)
389 jermar 360
{
361
    char *symbol = "";
362
 
958 jermar 363
    char *s = get_symtab_entry(istate->epc);
389 jermar 364
    if (s)
365
        symbol = s;
1735 decky 366
    fault_if_from_uspace(istate, "TLB Modified Exception on %p", cp0_badvaddr_read());
367
    panic("%x: TLB Modified Exception at %x(%s)\n", cp0_badvaddr_read(), istate->epc, symbol);
389 jermar 368
}
369
 
394 jermar 370
/** Try to find PTE for faulting address
371
 *
372
 * Try to find PTE for faulting address.
703 jermar 373
 * The AS->lock must be held on entry to this function.
394 jermar 374
 *
375
 * @param badvaddr Faulting virtual address.
1411 jermar 376
 * @param access Access mode that caused the fault.
1288 jermar 377
 * @param istate Pointer to interrupted state.
378
 * @param pfrc Pointer to variable where as_page_fault() return code will be stored.
394 jermar 379
 *
380
 * @return PTE on success, NULL otherwise.
381
 */
1780 jermar 382
pte_t *find_mapping_and_check(uintptr_t badvaddr, int access, istate_t *istate, int *pfrc)
394 jermar 383
{
396 jermar 384
    entry_hi_t hi;
394 jermar 385
    pte_t *pte;
386
 
396 jermar 387
    hi.value = cp0_entry_hi_read();
394 jermar 388
 
389
    /*
390
     * Handler cannot succeed if the ASIDs don't match.
391
     */
703 jermar 392
    if (hi.asid != AS->asid) {
393
        printf("EntryHi.asid=%d, AS->asid=%d\n", hi.asid, AS->asid);
394 jermar 394
        return NULL;
396 jermar 395
    }
703 jermar 396
 
394 jermar 397
    /*
703 jermar 398
     * Check if the mapping exists in page tables.
399
     */
756 jermar 400
    pte = page_mapping_find(AS, badvaddr);
831 jermar 401
    if (pte && pte->p) {
703 jermar 402
        /*
403
         * Mapping found in page tables.
404
         * Immediately succeed.
405
         */
406
        return pte;
407
    } else {
1288 jermar 408
        int rc;
409
 
703 jermar 410
        /*
411
         * Mapping not found in page tables.
412
         * Resort to higher-level page fault handler.
413
         */
1044 jermar 414
        page_table_unlock(AS, true);
1411 jermar 415
        switch (rc = as_page_fault(badvaddr, access, istate)) {
1288 jermar 416
        case AS_PF_OK:
703 jermar 417
            /*
418
             * The higher-level page fault handler succeeded,
419
             * The mapping ought to be in place.
420
             */
1044 jermar 421
            page_table_lock(AS, true);
756 jermar 422
            pte = page_mapping_find(AS, badvaddr);
831 jermar 423
            ASSERT(pte && pte->p);
703 jermar 424
            return pte;
1288 jermar 425
            break;
426
        case AS_PF_DEFER:
1044 jermar 427
            page_table_lock(AS, true);
1288 jermar 428
            *pfrc = AS_PF_DEFER;
429
            return NULL;
430
            break;
431
        case AS_PF_FAULT:
432
            page_table_lock(AS, true);
1044 jermar 433
            printf("Page fault.\n");
1288 jermar 434
            *pfrc = AS_PF_FAULT;
1044 jermar 435
            return NULL;
1288 jermar 436
            break;
437
        default:
438
            panic("unexpected rc (%d)\n", rc);
703 jermar 439
        }
1044 jermar 440
 
703 jermar 441
    }
394 jermar 442
}
443
 
3228 decky 444
void tlb_prepare_entry_lo(entry_lo_t *lo, bool g, bool v, bool d, bool cacheable, uintptr_t pfn)
394 jermar 445
{
399 jermar 446
    lo->value = 0;
394 jermar 447
    lo->g = g;
448
    lo->v = v;
449
    lo->d = d;
831 jermar 450
    lo->c = cacheable ? PAGE_CACHEABLE_EXC_WRITE : PAGE_UNCACHED;
394 jermar 451
    lo->pfn = pfn;
452
}
399 jermar 453
 
3228 decky 454
void tlb_prepare_entry_hi(entry_hi_t *hi, asid_t asid, uintptr_t addr)
399 jermar 455
{
983 palkovsky 456
    hi->value = ALIGN_DOWN(addr, PAGE_SIZE * 2);
399 jermar 457
    hi->asid = asid;
458
}
569 jermar 459
 
594 jermar 460
/** Print contents of TLB. */
569 jermar 461
void tlb_print(void)
462
{
612 jermar 463
    page_mask_t mask;
594 jermar 464
    entry_lo_t lo0, lo1;
704 jermar 465
    entry_hi_t hi, hi_save;
2720 decky 466
    unsigned int i;
594 jermar 467
 
704 jermar 468
    hi_save.value = cp0_entry_hi_read();
2720 decky 469
 
470
    printf("#  ASID VPN2   MASK G V D C PFN\n");
471
    printf("-- ---- ------ ---- - - - - ------\n");
472
 
594 jermar 473
    for (i = 0; i < TLB_ENTRY_COUNT; i++) {
474
        cp0_index_write(i);
475
        tlbr();
476
 
612 jermar 477
        mask.value = cp0_pagemask_read();
594 jermar 478
        hi.value = cp0_entry_hi_read();
479
        lo0.value = cp0_entry_lo0_read();
480
        lo1.value = cp0_entry_lo1_read();
481
 
2720 decky 482
        printf("%-2u %-4u %#6x %#4x %1u %1u %1u %1u %#6x\n",
483
            i, hi.asid, hi.vpn2, mask.mask,
484
            lo0.g, lo0.v, lo0.d, lo0.c, lo0.pfn);
485
        printf("                    %1u %1u %1u %1u %#6x\n",
486
            lo1.g, lo1.v, lo1.d, lo1.c, lo1.pfn);
594 jermar 487
    }
704 jermar 488
 
489
    cp0_entry_hi_write(hi_save.value);
569 jermar 490
}
598 jermar 491
 
618 jermar 492
/** Invalidate all not wired TLB entries. */
598 jermar 493
void tlb_invalidate_all(void)
494
{
599 jermar 495
    ipl_t ipl;
496
    entry_lo_t lo0, lo1;
704 jermar 497
    entry_hi_t hi_save;
598 jermar 498
    int i;
499
 
704 jermar 500
    hi_save.value = cp0_entry_hi_read();
599 jermar 501
    ipl = interrupts_disable();
598 jermar 502
 
618 jermar 503
    for (i = TLB_WIRED; i < TLB_ENTRY_COUNT; i++) {
598 jermar 504
        cp0_index_write(i);
599 jermar 505
        tlbr();
506
 
507
        lo0.value = cp0_entry_lo0_read();
508
        lo1.value = cp0_entry_lo1_read();
509
 
510
        lo0.v = 0;
511
        lo1.v = 0;
512
 
513
        cp0_entry_lo0_write(lo0.value);
514
        cp0_entry_lo1_write(lo1.value);
515
 
598 jermar 516
        tlbwi();
517
    }
599 jermar 518
 
519
    interrupts_restore(ipl);
704 jermar 520
    cp0_entry_hi_write(hi_save.value);
598 jermar 521
}
522
 
523
/** Invalidate all TLB entries belonging to specified address space.
524
 *
525
 * @param asid Address space identifier.
526
 */
527
void tlb_invalidate_asid(asid_t asid)
528
{
599 jermar 529
    ipl_t ipl;
530
    entry_lo_t lo0, lo1;
704 jermar 531
    entry_hi_t hi, hi_save;
598 jermar 532
    int i;
533
 
599 jermar 534
    ASSERT(asid != ASID_INVALID);
535
 
704 jermar 536
    hi_save.value = cp0_entry_hi_read();
599 jermar 537
    ipl = interrupts_disable();
538
 
598 jermar 539
    for (i = 0; i < TLB_ENTRY_COUNT; i++) {
540
        cp0_index_write(i);
541
        tlbr();
542
 
599 jermar 543
        hi.value = cp0_entry_hi_read();
544
 
598 jermar 545
        if (hi.asid == asid) {
599 jermar 546
            lo0.value = cp0_entry_lo0_read();
547
            lo1.value = cp0_entry_lo1_read();
548
 
549
            lo0.v = 0;
550
            lo1.v = 0;
551
 
552
            cp0_entry_lo0_write(lo0.value);
553
            cp0_entry_lo1_write(lo1.value);
554
 
598 jermar 555
            tlbwi();
556
        }
557
    }
599 jermar 558
 
559
    interrupts_restore(ipl);
704 jermar 560
    cp0_entry_hi_write(hi_save.value);
598 jermar 561
}
562
 
727 jermar 563
/** Invalidate TLB entries for specified page range belonging to specified address space.
598 jermar 564
 *
565
 * @param asid Address space identifier.
727 jermar 566
 * @param page First page whose TLB entry is to be invalidated.
567
 * @param cnt Number of entries to invalidate.
598 jermar 568
 */
1780 jermar 569
void tlb_invalidate_pages(asid_t asid, uintptr_t page, count_t cnt)
598 jermar 570
{
2745 decky 571
    unsigned int i;
599 jermar 572
    ipl_t ipl;
573
    entry_lo_t lo0, lo1;
704 jermar 574
    entry_hi_t hi, hi_save;
598 jermar 575
    tlb_index_t index;
576
 
599 jermar 577
    ASSERT(asid != ASID_INVALID);
578
 
704 jermar 579
    hi_save.value = cp0_entry_hi_read();
599 jermar 580
    ipl = interrupts_disable();
581
 
2745 decky 582
    for (i = 0; i < cnt + 1; i += 2) {
727 jermar 583
        hi.value = 0;
3228 decky 584
        tlb_prepare_entry_hi(&hi, asid, page + i * PAGE_SIZE);
727 jermar 585
        cp0_entry_hi_write(hi.value);
599 jermar 586
 
727 jermar 587
        tlbp();
588
        index.value = cp0_index_read();
598 jermar 589
 
727 jermar 590
        if (!index.p) {
591
            /* Entry was found, index register contains valid index. */
592
            tlbr();
599 jermar 593
 
727 jermar 594
            lo0.value = cp0_entry_lo0_read();
595
            lo1.value = cp0_entry_lo1_read();
599 jermar 596
 
727 jermar 597
            lo0.v = 0;
598
            lo1.v = 0;
599 jermar 599
 
727 jermar 600
            cp0_entry_lo0_write(lo0.value);
601
            cp0_entry_lo1_write(lo1.value);
599 jermar 602
 
727 jermar 603
            tlbwi();
604
        }
598 jermar 605
    }
599 jermar 606
 
607
    interrupts_restore(ipl);
704 jermar 608
    cp0_entry_hi_write(hi_save.value);
598 jermar 609
}
1702 cejka 610
 
1776 jermar 611
/** @}
1702 cejka 612
 */