Changeset a35b458 in mainline for kernel/arch/ia64/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/ia64/src
Files:
17 edited

Legend:

Unmodified
Added
Removed

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

    r3061bc1 ra35b458  
    4646FUNCTION_BEGIN(memcpy_to_uspace)
    4747        alloc loc0 = ar.pfs, 3, 1, 0, 0
    48        
     48
    4949        adds r14 = 7, in1
    5050        mov r2 = ar.lc
    … …  
    5353        cmp.ne p6, p7 = r14, in1
    5454        (p7) br.cond.dpnt 3f ;;
    55        
     55
    5656        0:
    57        
     57
    5858                cmp.ne p6, p7 = 0, in2
    5959                (p7) br.cond.dpnt 2f ;;
    … …  
    6262                (p6) mov r17 = r0 ;;
    6363                (p6) mov ar.lc = r14
    64        
     64
    6565        1:
    66        
     66
    6767                add r14 = r16, in1
    6868                add r15 = r16, in0
    … …  
    7272                st1 [r15] = r14
    7373                br.cloop.sptk.few 1b ;;
    74        
     74
    7575        2:
    76        
     76
    7777                mov ar.lc = r2
    7878                mov ar.pfs = loc0
    7979                br.ret.sptk.many rp
    80        
     80
    8181        3:
    82        
     82
    8383                adds r14 = 7, in0 ;;
    8484                and r14 = -8, r14 ;;
    … …  
    9292                (p6) mov r17 = r0 ;;
    9393                (p6) mov ar.lc = r14
    94        
     94
    9595        4:
    96        
     96
    9797                shladd r14 = r16, 3, r0
    9898                adds r16 = 1, r17 ;;
    … …  
    103103                st8 [r14] = r15
    104104                br.cloop.sptk.few 4b
    105        
     105
    106106        5:
    107        
     107
    108108                and r15 = 7, in2
    109109                shladd r14 = r18, 3, r0
    … …  
    116116                (p6) br.cond.dpnt 2b ;;
    117117                mov ar.lc = r15
    118        
     118
    119119        6:
    120        
     120
    121121                add r14 = r16, r17
    122122                add r15 = r16, in0
    … …  
    155155FUNCTION_BEGIN(switch_to_userspace)
    156156        alloc loc0 = ar.pfs, 6, 3, 0, 0
    157        
     157
    158158        /* Disable interruption collection and interrupts */
    159159        rsm (PSR_IC_MASK | PSR_I_MASK)
    160160        srlz.d ;;
    161161        srlz.i ;;
    162        
     162
    163163        mov cr.ipsr = in4
    164164        mov cr.iip = in0
    165165        mov r12 = in1
    166        
     166
    167167        xor r1 = r1, r1
    168        
     168
    169169        /* r2 is defined to hold pcb_ptr - set it to 0 */
    170170        xor r2 = r2, r2
    171        
     171
    172172        mov loc1 = cr.ifs
    173173        movl loc2 = PFM_MASK ;;
    174174        and loc1 = loc2, loc1 ;;
    175175        mov cr.ifs = loc1 ;;  /* prevent decrementing BSP by rfi */
    176        
     176
    177177        invala
    178        
     178
    179179        mov loc1 = ar.rsc ;;
    180180        and loc1 = ~3, loc1 ;;
    181181        mov ar.rsc = loc1 ;;  /* put RSE into enforced lazy mode */
    182        
     182
    183183        flushrs ;;
    184        
     184
    185185        mov ar.bspstore = in2 ;;
    186186        mov ar.rsc = in5 ;;
    187        
     187
    188188        mov r8 = in3
    189        
     189
    190190        rfi ;;
    191191FUNCTION_END(switch_to_userspace)

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

    r3061bc1 ra35b458  
    4545        flushrs
    4646        mov loc4 = ar.bsp
    47        
     47
    4848        /*
    4949         * Put RSE to enforced lazy mode.
    … …  
    117117
    118118        mov loc2 = ar.unat
    119        
     119
    120120        /*
    121121         * Save application registers
    … …  
    177177
    178178        mov ar.unat = loc1
    179        
     179
    180180        add r8 = r0, r0, 1      /* context_save returns 1 */
    181181        br.ret.sptk.many b0
    … …  
    239239        ld8 loc5 = [loc14]      /* load ar.rnat */
    240240        ld8 loc6 = [loc15]      /* load ar.lc */
    241        
     241
    242242        .auto
    243243
    … …  
    274274        mov ar.unat = loc2 ;;
    275275        mov ar.lc = loc6
    276        
     276
    277277        /*
    278278         * Restore general registers including NaT bits
    … …  
    332332        ldf.fill f30 = [loc48]
    333333        ldf.fill f31 = [loc49]
    334        
     334
    335335        mov ar.unat = loc1
    336        
     336
    337337        mov r8 = r0                     /* context_restore returns 0 */
    338338        br.ret.sptk.many b0

  • kernel/arch/ia64/src/cpu/cpu.c

    r3061bc1 ra35b458  
    5454        const char *family_str;
    5555        char vendor[2 * sizeof(uint64_t) + 1];
    56        
     56
    5757        memcpy(vendor, &CPU->arch.cpuid0, 8);
    5858        memcpy(vendor + 8, &CPU->arch.cpuid1, 8);
    5959        vendor[sizeof(vendor) - 1] = 0;
    60        
     60
    6161        switch (m->arch.cpuid3.family) {
    6262        case FAMILY_ITANIUM:
    … …  
    7070                break;
    7171        }
    72        
     72
    7373        printf("cpu%d: %s (%s), archrev=%d, model=%d, revision=%d\n", CPU->id,
    7474            family_str, vendor, CPU->arch.cpuid3.archrev,

  • kernel/arch/ia64/src/ddi/ddi.c

    r3061bc1 ra35b458  
    5959                if (task->arch.iomap == NULL)
    6060                        return ENOMEM;
    61                
     61
    6262                void *store = malloc(bitmap_size(IO_MEMMAP_PAGES), 0);
    6363                if (store == NULL)
    6464                        return ENOMEM;
    65                
     65
    6666                bitmap_initialize(task->arch.iomap, IO_MEMMAP_PAGES, store);
    6767                bitmap_clear_range(task->arch.iomap, 0, IO_MEMMAP_PAGES);
    6868        }
    69        
     69
    7070        uintptr_t iopage = ioaddr / PORTS_PER_PAGE;
    7171        size = ALIGN_UP(size + ioaddr - 4 * iopage, PORTS_PER_PAGE);
    7272        bitmap_set_range(task->arch.iomap, iopage, size / 4);
    73        
     73
    7474        return EOK;
    7575}
    … …  
    9393        size = ALIGN_UP(size + ioaddr - 4 * iopage, PORTS_PER_PAGE);
    9494        bitmap_clear_range(task->arch.iomap, iopage, size / 4);
    95        
     95
    9696        return EOK;
    9797}

  • kernel/arch/ia64/src/drivers/it.c

    r3061bc1 ra35b458  
    6868                it_irq.handler = it_interrupt;
    6969                irq_register(&it_irq);
    70                
     70
    7171                uint64_t base_freq;
    7272                base_freq  = ((bootinfo->freq_scale) & FREQ_NUMERATOR_MASK) >>
    … …  
    7575                base_freq /= ((bootinfo->freq_scale) & FREQ_DENOMINATOR_MASK) >>
    7676                    FREQ_DENOMINATOR_SHIFT;
    77                
     77
    7878                it_delta = base_freq / HZ;
    7979        }
    80        
     80
    8181        /* Initialize Interval Timer external interrupt vector */
    8282        cr_itv_t itv;
    83        
     83
    8484        itv.value = itv_read();
    8585        itv.vector = INTERRUPT_TIMER;
    8686        itv.m = 0;
    8787        itv_write(itv.value);
    88        
     88
    8989        /* Set Interval Timer Counter to zero */
    9090        itc_write(0);
    91        
     91
    9292        /* Generate first Interval Timer interrupt in IT_DELTA ticks */
    9393        itm_write(IT_DELTA);
    94        
     94
    9595        /* Propagate changes */
    9696        srlz_d();
    … …  
    113113{
    114114        eoi_write(EOI);
    115        
     115
    116116        int64_t itm = itm_read();
    117        
     117
    118118        while (true) {
    119119                int64_t itc = itc_read();
    120120                itc += IT_SERVICE_CLOCKS;
    121                
     121
    122122                itm += IT_DELTA;
    123123                if (itm - itc < 0)
    … …  
    126126                        break;
    127127        }
    128        
     128
    129129        itm_write(itm);
    130130        srlz_d();  /* Propagate changes */
    131        
     131
    132132        /*
    133133         * We are holding a lock which prevents preemption.

  • kernel/arch/ia64/src/drivers/ski.c

    r3061bc1 ra35b458  
    4949        /** Interval between polling in microseconds */
    5050        POLL_INTERVAL = 10000,  /* 0.01 s */
    51        
     51
    5252        /** Max. number of characters to pull out at a time */
    5353        POLL_LIMIT = 30,
    54        
     54
    5555        SKI_INIT_CONSOLE = 20,
    5656        SKI_GETCHAR      = 21,
    … …  
    8282{
    8383        uint64_t ch;
    84        
     84
    8585        asm volatile (
    8686                "mov r15 = %1\n"
    8787                "break 0x80000;;\n"  /* modifies r8 */
    8888                "mov %0 = r8;;\n"
    89                
     89
    9090                : "=r" (ch)
    9191                : "i" (SKI_GETCHAR)
    9292                : "r15", "r8"
    9393        );
    94        
     94
    9595        return (wchar_t) ch;
    9696}
    … …  
    103103{
    104104        int count = POLL_LIMIT;
    105        
     105
    106106        while (count > 0) {
    107107                wchar_t ch = ski_getchar();
    108                
     108
    109109                if (ch == '\0')
    110110                        break;
    111                
     111
    112112                indev_push_character(instance->srlnin, ch);
    113113                --count;
    … …  
    119119{
    120120        ski_instance_t *instance = (ski_instance_t *) arg;
    121        
     121
    122122        while (true) {
    123123                // TODO FIXME:
    … …  
    126126                if (console_override)
    127127                        poll_keyboard(instance);
    128                
     128
    129129                thread_usleep(POLL_INTERVAL);
    130130        }
    … …  
    141141        if (instance)
    142142                return;
    143        
     143
    144144        asm volatile (
    145145                "mov r15 = %0\n"
    … …  
    149149                : "r15", "r8"
    150150        );
    151        
     151
    152152        instance = malloc(sizeof(ski_instance_t), FRAME_ATOMIC);
    153        
     153
    154154        if (instance) {
    155155                instance->thread = thread_create(kskipoll, instance, TASK,
    156156                    THREAD_FLAG_UNCOUNTED, "kskipoll");
    157                
     157
    158158                if (!instance->thread) {
    159159                        free(instance);
    … …  
    161161                        return;
    162162                }
    163                
     163
    164164                instance->srlnin = NULL;
    165165        }
    … …  
    196196                        if (ch == '\n')
    197197                                ski_do_putchar('\r');
    198                        
     198
    199199                        ski_do_putchar(ch);
    200200                } else
    … …  
    208208        if (!instance)
    209209                return NULL;
    210        
     210
    211211        outdev_t *skidev = malloc(sizeof(outdev_t), FRAME_ATOMIC);
    212212        if (!skidev)
    213213                return NULL;
    214        
     214
    215215        outdev_initialize("skidev", skidev, &skidev_ops);
    216216        skidev->data = instance;
    217        
     217
    218218        if (!fb_exported) {
    219219                /*
    … …  
    224224                sysinfo_set_item_val("fb", NULL, true);
    225225                sysinfo_set_item_val("fb.kind", NULL, 6);
    226                
     226
    227227                fb_exported = true;
    228228        }
    229        
     229
    230230        return skidev;
    231231}
    … …  
    241241        assert(instance);
    242242        assert(srlnin);
    243        
     243
    244244        instance->srlnin = srlnin;
    245245        thread_ready(instance->thread);
    246        
     246
    247247        sysinfo_set_item_val("kbd", NULL, true);
    248248        sysinfo_set_item_val("kbd.type", NULL, KBD_SKI);

  • kernel/arch/ia64/src/fpu_context.c

    r3061bc1 ra35b458  
    103103                [f61] "=m" (fctx->fr[29])
    104104        );
    105        
     105
    106106        asm volatile (
    107107                "stf.spill %[f62] = f62\n"
    … …  
    314314                [f61] "m" (fctx->fr[29])
    315315        );
    316        
     316
    317317        asm volatile (
    318318                "ldf.fill f62 = %[f62]\n"

  • kernel/arch/ia64/src/ia64.c

    r3061bc1 ra35b458  
    108108            PAGE_WRITE | PAGE_NOT_CACHEABLE);
    109109        int i;
    110        
     110
    111111        int myid, myeid;
    112        
     112
    113113        myid = ia64_get_cpu_id();
    114114        myeid = ia64_get_cpu_eid();
    … …  
    167167                }
    168168        }
    169        
     169
    170170        outdev_t *skidev = skiout_init();
    171171        if (skidev)
    172172                stdout_wire(skidev);
    173173#endif
    174        
     174
    175175#ifdef CONFIG_EGA
    176176        outdev_t *egadev = ega_init(EGA_BASE, EGA_VIDEORAM);
    … …  
    178178                stdout_wire(egadev);
    179179#endif
    180        
     180
    181181#ifdef CONFIG_NS16550
    182182        ns16550_instance_t *ns16550_instance
    … …  
    191191                }
    192192        }
    193        
     193
    194194        sysinfo_set_item_val("kbd", NULL, true);
    195195        sysinfo_set_item_val("kbd.inr", NULL, NS16550_IRQ);
    … …  
    198198            (uintptr_t) NS16550_BASE);
    199199#endif
    200        
     200
    201201#ifdef CONFIG_I8042
    202202        i8042_instance_t *i8042_instance = i8042_init((i8042_t *) I8042_BASE,
    … …  
    211211        }
    212212#endif
    213        
     213
    214214        sysinfo_set_item_val("ia64_iospace", NULL, true);
    215215        sysinfo_set_item_val("ia64_iospace.address", NULL, true);
    … …  
    251251            kernel_uarg->uspace_stack_size / 2,
    252252            (uintptr_t) kernel_uarg->uspace_uarg, psr.value, rsc.value);
    253        
     253
    254254        while (1);
    255255}
    … …  
    274274        fptr->fnc = (sysarg_t) addr;
    275275        fptr->gp = ((sysarg_t *) caller)[1];
    276        
     276
    277277        return (void *) fptr;
    278278}

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

    r3061bc1 ra35b458  
    124124{
    125125        assert(n <= VECTOR_MAX);
    126        
     126
    127127        if (n >= VECTORS_16_BUNDLE_START)
    128128                return vector_names_16_bundle[n - VECTORS_16_BUNDLE_START];
    … …  
    141141        printf("cr.isr=%#0" PRIx64 "\tcr.ipsr=%#0" PRIx64 "\n",
    142142            istate->cr_isr.value, istate->cr_ipsr.value);
    143        
     143
    144144        printf("cr.iip=%#0" PRIxPTR ", #%u\t(%s)\n",
    145145            istate->cr_iip, istate->cr_isr.ei,
    … …  
    154154{
    155155        const char *desc;
    156        
     156
    157157        switch (istate->cr_isr.ge_code) {
    158158        case GE_ILLEGALOP:
    … …  
    178178                break;
    179179        }
    180        
     180
    181181        fault_if_from_uspace(istate, "General Exception (%s).", desc);
    182182        panic_badtrap(istate, n, "General Exception (%s).", desc);
    … …  
    209209                istate->cr_ipsr.ri++;
    210210        }
    211        
     211
    212212        interrupts_enable();
    213213        ret = syscall_handler(istate->in0, istate->in1, istate->in2,
    … …  
    236236{
    237237        cr_ivr_t ivr;
    238        
     238
    239239        ivr.value = ivr_read();
    240240        srlz_d();
    241        
     241
    242242        irq_t *irq;
    243        
     243
    244244        switch (ivr.vector) {
    245245        case INTERRUPT_SPURIOUS:
    … …  
    248248#endif
    249249                break;
    250        
     250
    251251#ifdef CONFIG_SMP
    252252        case VECTOR_TLB_SHOOTDOWN_IPI:
    … …  
    255255                break;
    256256#endif
    257        
     257
    258258        case INTERRUPT_TIMER:
    259259                irq = irq_dispatch_and_lock(ivr.vector);

  • kernel/arch/ia64/src/ivt.S

    r3061bc1 ra35b458  
    5757        mov r19 = cr.ipsr
    5858        mov r20 = cr.isr ;;
    59        
     59
    6060    /* 2. Move IIP to IIPA. */
    6161        mov cr.iipa = r18
    62        
     62
    6363    /* 3. Sign extend IIM[20:0], shift left by 4 and add to IIP. */
    6464        shl r17 = r17, 43 ;;    /* shift bit 20 to bit 63 */
    … …  
    6666        add r18 = r18, r17 ;;
    6767        mov cr.iip = r18
    68        
     68
    6969    /* 4. Set IPSR.ri to 0. */
    7070        dep r19 = 0, r19, PSR_RI_SHIFT, PSR_RI_LEN ;;
    7171        mov cr.ipsr = r19
    72        
     72
    7373    /* 5. Check whether IPSR.tb or IPSR.ss is set. */
    7474
    … …  
    7676         * Implement this when Taken Branch and Single Step traps can occur.
    7777         */
    78    
     78
    7979    /* 6. Restore predicates and return from interruption. */
    8080        mov pr = r16 ;;
    … …  
    104104SYMBOL(heavyweight_handler)
    105105    /* 1. copy interrupt registers into bank 0 */
    106    
     106
    107107        /*
    108108         * Note that r24-r31 from bank 0 can be used only as long as PSR.ic = 0.
    109109         */
    110        
     110
    111111        /* Set up FPU as in interrupted context. */
    112112        mov r24 = psr
    … …  
    126126        mov r27 = cr.isr
    127127        mov r28 = cr.ifa
    128        
     128
    129129    /* 2. preserve predicate register into bank 0 */
    130130        mov r29 = pr ;;
    131        
     131
    132132    /* 3. switch to kernel memory stack */
    133133        mov r30 = cr.ipsr
    … …  
    149149         */
    150150(p3)    cmp.eq p3, p4 = VRN_KERNEL, r31 ;;
    151        
     151
    152152        /*
    153153         * Now, p4 is true iff the stack needs to be switched to kernel stack.
    … …  
    155155        mov r30 = r12
    156156(p4)    mov r12 = R_KSTACK ;;
    157        
     157
    158158        add r12 = -STACK_FRAME_SIZE, r12 ;;
    159159        add r31 = STACK_SCRATCH_AREA_SIZE + ISTATE_OFFSET_IN6, r12
    … …  
    166166         */
    167167        cmp.eq p6, p5 = EXC_BREAK_INSTRUCTION, R_VECTOR ;;
    168        
     168
    169169        /*
    170170         * From now on, if this is break_instruction handler, p6 is true and p5
    … …  
    181181(p6)    st8 [r31] = r32, -STACK_ITEM_SIZE ;;    /* save in0 */
    182182(p5)    add r31 = -(7 * STACK_ITEM_SIZE), r31 ;;
    183    
     183
    184184        st8 [r31] = r30, -STACK_ITEM_SIZE ;;    /* save old stack pointer */
    185        
     185
    186186        st8 [r31] = r29, -STACK_ITEM_SIZE ;;    /* save predicate registers */
    187187
    … …  
    197197        cover
    198198        mov r26 = cr.ifs
    199        
     199
    200200        st8 [r31] = r24, -STACK_ITEM_SIZE ;;    /* save ar.rsc */
    201201        st8 [r31] = r25, -STACK_ITEM_SIZE ;;    /* save ar.pfs */
    202202        st8 [r31] = r26, -STACK_ITEM_SIZE       /* save ar.ifs */
    203        
     203
    204204        and r24 = ~(RSC_PL_MASK), r24 ;;
    205205        and r30 = ~(RSC_MODE_MASK), r24 ;;
    206206        mov ar.rsc = r30 ;;             /* update RSE state */
    207        
     207
    208208        mov r27 = ar.rnat
    209209        mov r28 = ar.bspstore ;;
    210        
     210
    211211        /*
    212212         * Inspect BSPSTORE to figure out whether it is necessary to switch to
    … …  
    215215(p1)    shr.u r30 = r28, VRN_SHIFT ;;
    216216(p1)    cmp.eq p1, p2 = VRN_KERNEL, r30 ;;
    217        
     217
    218218        /*
    219219         * If BSPSTORE needs to be switched, p1 is false and p2 is true.
    … …  
    222222(p2)    mov r30 = R_KSTACK_BSP ;;
    223223(p2)    mov ar.bspstore = r30 ;;
    224        
     224
    225225        mov r29 = ar.bsp
    226        
     226
    227227        st8 [r31] = r27, -STACK_ITEM_SIZE ;;    /* save ar.rnat */
    228228        st8 [r31] = r30, -STACK_ITEM_SIZE ;;    /* save new value written to ar.bspstore */
    229229        st8 [r31] = r28, -STACK_ITEM_SIZE ;;    /* save ar.bspstore */
    230230        st8 [r31] = r29, -STACK_ITEM_SIZE       /* save ar.bsp */
    231        
     231
    232232        mov ar.rsc = r24                /* restore RSE's setting + kernel privileges */
    233        
     233
    234234    /* steps 6 - 15 are done by heavyweight_handler_inner() */
    235235        mov R_RET = b0                  /* save b0 belonging to interrupted context */
    … …  
    292292        ld8 r29 = [r31], +STACK_ITEM_SIZE ;;    /* load predicate registers */
    293293        mov pr = r29
    294        
     294
    295295    /* 19. return from interruption */
    296296        ld8 r12 = [r31]                         /* load stack pointer */
    … …  
    303303         */
    304304        alloc loc0 = ar.pfs, 0, 48, 2, 0 ;;
    305        
     305
    306306        /* bank 0 is going to be shadowed, copy essential data from there */
    307307        mov loc1 = R_RET        /* b0 belonging to interrupted context */
    308308        mov loc2 = R_HANDLER
    309309        mov out0 = R_VECTOR
    310        
     310
    311311        add out1 = STACK_SCRATCH_AREA_SIZE, r12
    312312
    … …  
    315315        bsw.1 ;;
    316316        srlz.d
    317        
     317
    318318    /* 7. preserve branch and application registers */
    319319        mov loc3 = ar.unat
    … …  
    323323        mov loc7 = ar.csd
    324324        mov loc8 = ar.ssd
    325        
     325
    326326        mov loc9 = b0
    327327        mov loc10 = b1
    … …  
    332332        mov loc15 = b6
    333333        mov loc16 = b7
    334        
     334
    335335    /* 8. preserve general and floating-point registers */
    336336        mov loc17 = r1
    … …  
    374374        add r30 = ISTATE_OFFSET_F6 + STACK_SCRATCH_AREA_SIZE, r12
    375375        add r31 = ISTATE_OFFSET_F7 + STACK_SCRATCH_AREA_SIZE, r12 ;;
    376        
     376
    377377        stf.spill [r26] = f2, 8 * FLOAT_ITEM_SIZE
    378378        stf.spill [r27] = f3, 8 * FLOAT_ITEM_SIZE
    … …  
    410410
    411411        mov loc47 = ar.fpsr     /* preserve floating point status register */
    412    
     412
    413413    /* 9. skipped (will not enable interrupts) */
    414414        /*
    … …  
    420420    /* 10. call handler */
    421421        movl r1 = __gp
    422    
     422
    423423        mov b1 = loc2
    424424        br.call.sptk.many b0 = b1
    … …  
    426426    /* 11. return from handler */
    4274270:
    428        
     428
    429429    /* 12. skipped (will not disable interrupts) */
    430430        /*
    … …  
    477477        ldf.fill f30 = [r30]
    478478        ldf.fill f31 = [r31] ;;
    479        
     479
    480480        mov r1 = loc17
    481481        mov r2 = loc18
    … …  
    511511
    512512        mov ar.fpsr = loc47     /* restore floating point status register */
    513        
     513
    514514    /* 14. restore branch and application registers */
    515515        mov ar.unat = loc3
    … …  
    519519        mov ar.csd = loc7
    520520        mov ar.ssd = loc8
    521        
     521
    522522        mov b0 = loc9
    523523        mov b1 = loc10
    … …  
    528528        mov b6 = loc15
    529529        mov b7 = loc16
    530        
     530
    531531    /* 15. disable PSR.ic and switch to bank 0 */
    532532        rsm PSR_IC_MASK
    … …  
    578578        HEAVYWEIGHT_HANDLER 0x5e
    579579        HEAVYWEIGHT_HANDLER 0x5f
    580        
     580
    581581        HEAVYWEIGHT_HANDLER 0x60
    582582        HEAVYWEIGHT_HANDLER 0x61

  • kernel/arch/ia64/src/mm/as.c

    r3061bc1 ra35b458  
    5858        region_register_t rr;
    5959        int i;
    60        
     60
    6161        assert(as->asid != ASID_INVALID);
    62        
     62
    6363        /*
    6464         * Load respective ASID (7 consecutive RIDs) to
    … …  
    6868                if (i == VRN_KERNEL)
    6969                        continue;
    70                
     70
    7171                rr.word = rr_read(i);
    7272                rr.map.ve = false;              /* disable VHPT walker */

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

    r3061bc1 ra35b458  
    9292        if (config.cpu_active > 1)
    9393                return;
    94        
     94
    9595        frame_common_arch_init(true);
    96        
     96
    9797        /*
    9898         * Blacklist ROM regions.
    … …  
    112112        if (config.cpu_active > 1)
    113113                return;
    114        
     114
    115115        frame_common_arch_init(false);
    116116}

  • kernel/arch/ia64/src/mm/page.c

    r3061bc1 ra35b458  
    124124        vrn = page >> VRN_SHIFT;
    125125        rid = ASID2RID(asid, vrn);
    126        
     126
    127127        rr_save.word = rr_read(vrn);
    128128        if (rr_save.map.rid == rid) {
    … …  
    133133                return v;
    134134        }
    135        
     135
    136136        /*
    137137         * The RID must be written to some region register.
    … …  
    171171        vrn = page >> VRN_SHIFT;
    172172        rid = ASID2RID(asid, vrn);
    173        
     173
    174174        rr_save.word = rr_read(vrn);
    175175        if (rr_save.map.rid == rid) {
    … …  
    179179                return ttag(page) == v->present.tag.tag_word;
    180180        }
    181        
     181
    182182        /*
    183183         * The RID must be written to some region register.
    … …  
    218218        vrn = page >> VRN_SHIFT;
    219219        rid = ASID2RID(asid, vrn);
    220        
     220
    221221        /*
    222222         * Compute ttag.
    … …  
    231231        srlz_i();
    232232        srlz_d();
    233        
     233
    234234        /*
    235235         * Clear the entry.
    … …  
    239239        v->word[2] = 0;
    240240        v->word[3] = 0;
    241        
     241
    242242        v->present.p = true;
    243243        v->present.ma = (flags & PAGE_CACHEABLE) ?

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

    r3061bc1 ra35b458  
    6161        uintptr_t adr;
    6262        uint32_t count1, count2, stride1, stride2;
    63        
     63
    6464        unsigned int i, j;
    65        
     65
    6666        adr = PAL_PTCE_INFO_BASE();
    6767        count1 = PAL_PTCE_INFO_COUNT1();
    … …  
    6969        stride1 = PAL_PTCE_INFO_STRIDE1();
    7070        stride2 = PAL_PTCE_INFO_STRIDE2();
    71        
     71
    7272        ipl = interrupts_disable();
    73        
     73
    7474        for (i = 0; i < count1; i++) {
    7575                for (j = 0; j < count2; j++) {
    … …  
    8282                adr += stride1;
    8383        }
    84        
     84
    8585        interrupts_restore(ipl);
    86        
     86
    8787        srlz_d();
    8888        srlz_i();
    89        
     89
    9090#ifdef CONFIG_VHPT
    9191        vhpt_invalidate_all();
    … …  
    110110        int b = 0;
    111111        int c = cnt;
    112        
     112
    113113        uintptr_t va;
    114114        va = page;
    115        
     115
    116116        rr.word = rr_read(VA2VRN(page));
    117117        if ((restore_rr = (rr.map.rid != ASID2RID(asid, VA2VRN(page))))) {
    … …  
    121121                 */
    122122                region_register_t rr0;
    123                
     123
    124124                rr0 = rr;
    125125                rr0.map.rid = ASID2RID(asid, VA2VRN(page));
    … …  
    128128                srlz_i();
    129129        }
    130        
     130
    131131        while (c >>= 1)
    132132                b++;
    133133        b >>= 1;
    134134        uint64_t ps;
    135        
     135
    136136        switch (b) {
    137137        case 0: /* cnt 1 - 3 */
    … …  
    172172                break;
    173173        }
    174        
     174
    175175        for (; va < (page + cnt * PAGE_SIZE); va += (1UL << ps))
    176176                asm volatile (
    … …  
    179179                           [ps] "r" (ps << 2)
    180180                );
    181        
     181
    182182        srlz_d();
    183183        srlz_i();
    184        
     184
    185185        if (restore_rr) {
    186186                rr_write(VA2VRN(page), rr.word);
    … …  
    229229        region_register_t rr;
    230230        bool restore_rr = false;
    231        
     231
    232232        rr.word = rr_read(VA2VRN(va));
    233233        if ((restore_rr = (rr.map.rid != ASID2RID(asid, VA2VRN(va))))) {
    … …  
    237237                 */
    238238                region_register_t rr0;
    239                
     239
    240240                rr0 = rr;
    241241                rr0.map.rid = ASID2RID(asid, VA2VRN(va));
    … …  
    244244                srlz_i();
    245245        }
    246        
     246
    247247        asm volatile (
    248248                "mov r8 = psr ;;\n"
    … …  
    264264                : "p6", "p7", "r8"
    265265        );
    266        
     266
    267267        if (restore_rr) {
    268268                rr_write(VA2VRN(va), rr.word);
    … …  
    316316        region_register_t rr;
    317317        bool restore_rr = false;
    318        
     318
    319319        rr.word = rr_read(VA2VRN(va));
    320320        if ((restore_rr = (rr.map.rid != ASID2RID(asid, VA2VRN(va))))) {
    … …  
    324324                 */
    325325                region_register_t rr0;
    326                
     326
    327327                rr0 = rr;
    328328                rr0.map.rid = ASID2RID(asid, VA2VRN(va));
    … …  
    331331                srlz_i();
    332332        }
    333        
     333
    334334        asm volatile (
    335335                "mov r8 = psr ;;\n"
    … …  
    352352                : "p6", "p7", "r8"
    353353        );
    354        
     354
    355355        if (restore_rr) {
    356356                rr_write(VA2VRN(va), rr.word);
    … …  
    373373{
    374374        tlb_entry_t entry;
    375        
     375
    376376        entry.word[0] = 0;
    377377        entry.word[1] = 0;
    378        
     378
    379379        entry.p = true;           /* present */
    380380        entry.ma = MA_WRITEBACK;
    … …  
    385385        entry.ppn = frame >> PPN_SHIFT;
    386386        entry.ps = PAGE_WIDTH;
    387        
     387
    388388        if (dtr)
    389389                dtr_mapping_insert(page, ASID_KERNEL, entry, tr);
    … …  
    418418{
    419419        tlb_entry_t entry;
    420        
     420
    421421        entry.word[0] = 0;
    422422        entry.word[1] = 0;
    423        
     423
    424424        entry.p = t->p;
    425425        entry.ma = t->c ? MA_WRITEBACK : MA_UNCACHEABLE;
    … …  
    430430        entry.ppn = t->frame >> PPN_SHIFT;
    431431        entry.ps = PAGE_WIDTH;
    432        
     432
    433433        dtc_mapping_insert(t->page, t->as->asid, entry);
    434        
     434
    435435#ifdef CONFIG_VHPT
    436436        vhpt_mapping_insert(t->page, t->as->asid, entry);
    … …  
    446446{
    447447        tlb_entry_t entry;
    448        
     448
    449449        entry.word[0] = 0;
    450450        entry.word[1] = 0;
    451        
     451
    452452        assert(t->x);
    453        
     453
    454454        entry.p = t->p;
    455455        entry.ma = t->c ? MA_WRITEBACK : MA_UNCACHEABLE;
    … …  
    459459        entry.ppn = t->frame >> PPN_SHIFT;
    460460        entry.ps = PAGE_WIDTH;
    461        
     461
    462462        itc_mapping_insert(t->page, t->as->asid, entry);
    463        
     463
    464464#ifdef CONFIG_VHPT
    465465        vhpt_mapping_insert(t->page, t->as->asid, entry);
    … …  
    486486        uintptr_t va;
    487487        pte_t t;
    488        
     488
    489489        va = istate->cr_ifa; /* faulting address */
    490        
     490
    491491        assert(!is_kernel_fault(va));
    492492
    … …  
    532532                        uint64_t io_page = (va & ((1 << LEGACYIO_PAGE_WIDTH) - 1)) >>
    533533                            LEGACYIO_SINGLE_PAGE_WIDTH;
    534                        
     534
    535535                        if (is_io_page_accessible(io_page)) {
    536536                                uint64_t page, frame;
    537                                
     537
    538538                                page = LEGACYIO_USER_BASE +
    539539                                    (1 << LEGACYIO_SINGLE_PAGE_WIDTH) * io_page;
    540540                                frame = LEGACYIO_PHYS_BASE +
    541541                                    (1 << LEGACYIO_SINGLE_PAGE_WIDTH) * io_page;
    542                                
     542
    543543                                tlb_entry_t entry;
    544                                
     544
    545545                                entry.word[0] = 0;
    546546                                entry.word[1] = 0;
    547                                
     547
    548548                                entry.p = true;             /* present */
    549549                                entry.ma = MA_UNCACHEABLE;
    … …  
    554554                                entry.ppn = frame >> PPN_SHIFT;
    555555                                entry.ps = LEGACYIO_SINGLE_PAGE_WIDTH;
    556                                
     556
    557557                                dtc_mapping_insert(page, TASK->as->asid, entry);
    558558                                return 1;
    … …  
    563563                }
    564564        }
    565        
     565
    566566        return 0;
    567567}
    … …  
    586586                return;
    587587        }
    588        
     588
    589589        uintptr_t va = istate->cr_ifa;  /* faulting address */
    590590        as_t *as = AS;
    591        
     591
    592592        if (is_kernel_fault(va)) {
    593593                if (va < end_of_identity) {
    … …  
    601601                }
    602602        }
    603        
    604        
     603
     604
    605605        pte_t t;
    606606        bool found = page_mapping_find(as, va, true, &t);
    … …  
    616616                if (try_memmap_io_insertion(va, istate))
    617617                        return;
    618                
     618
    619619                /*
    620620                 * Forward the page fault to the address space page fault
    … …  
    649649        pte_t t;
    650650        as_t *as = AS;
    651        
     651
    652652        va = istate->cr_ifa;  /* faulting address */
    653        
     653
    654654        if (is_kernel_fault(va))
    655655                as = AS_KERNEL;
    … …  
    683683        uintptr_t va;
    684684        pte_t t;
    685        
     685
    686686        va = istate->cr_ifa;  /* faulting address */
    687687
    688688        assert(!is_kernel_fault(va));
    689        
     689
    690690        bool found = page_mapping_find(AS, va, true, &t);
    691691
    … …  
    717717        pte_t t;
    718718        as_t *as = AS;
    719        
     719
    720720        va = istate->cr_ifa;  /* faulting address */
    721        
     721
    722722        if (is_kernel_fault(va))
    723723                as = AS_KERNEL;
    … …  
    755755        uintptr_t va;
    756756        pte_t t;
    757        
     757
    758758        va = istate->cr_ifa;  /* faulting address */
    759759
    760760        assert(!is_kernel_fault(va));
    761        
     761
    762762        /*
    763763         * Assume a write to a read-only page.
    … …  
    782782        uintptr_t va;
    783783        pte_t t;
    784        
     784
    785785        va = istate->cr_ifa;  /* faulting address */
    786        
     786
    787787        assert(!is_kernel_fault(va));
    788788
    … …  
    790790
    791791        assert(found);
    792        
     792
    793793        if (t.p) {
    794794                /*

  • kernel/arch/ia64/src/mm/vhpt.c

    r3061bc1 ra35b458  
    4646        if (!vhpt_frame)
    4747                panic("Kernel configured with VHPT but no memory for table.");
    48        
     48
    4949        vhpt_base = (vhpt_entry_t *) PA2KA(vhpt_frame);
    5050        vhpt_invalidate_all();
    … …  
    5959        rid_t rid;
    6060        uint64_t tag;
    61        
     61
    6262        vhpt_entry_t *ventry;
    63        
     63
    6464        vrn = va >> VRN_SHIFT;
    6565        rid = ASID2RID(asid, vrn);
    66        
     66
    6767        rr_save.word = rr_read(vrn);
    6868        rr.word = rr_save.word;
    … …  
    7070        rr_write(vrn, rr.word);
    7171        srlz_i();
    72        
     72
    7373        ventry = (vhpt_entry_t *) thash(va);
    7474        tag = ttag(va);
    … …  
    7676        srlz_i();
    7777        srlz_d();
    78        
     78
    7979        ventry->word[0] = entry.word[0];
    8080        ventry->word[1] = entry.word[1];

  • kernel/arch/ia64/src/proc/scheduler.c

    r3061bc1 ra35b458  
    5454{
    5555        uintptr_t base;
    56        
     56
    5757        base = ALIGN_DOWN(config.base, 1 << KERNEL_PAGE_WIDTH);
    5858
    … …  
    6363                 * Use DTR[TR_KSTACK1] and DTR[TR_KSTACK2] to map it.
    6464                 */
    65                  
     65
    6666                /* purge DTR[TR_STACK1] and DTR[TR_STACK2] */
    6767                dtr_purge((uintptr_t) THREAD->kstack, PAGE_WIDTH+1);
    68                
     68
    6969                /* insert DTR[TR_STACK1] and DTR[TR_STACK2] */
    7070                dtlb_kernel_mapping_insert((uintptr_t) THREAD->kstack,
    … …  
    7474                    DTR_KSTACK2);
    7575        }
    76        
     76
    7777        /*
    7878         * Record address of kernel backing store to bank 0 r22.

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

    r3061bc1 ra35b458  
    5454SYMBOL(kernel_image_start)
    5555        .auto
    56        
     56
    5757        mov psr.l = r0
    5858        srlz.i
    5959        srlz.d
    60        
     60
    6161        # Fill TR.i and TR.d using Region Register #VRN_KERNEL
    62        
     62
    6363        movl r8 = (VRN_KERNEL << VRN_SHIFT)
    6464        mov r9 = rr[r8]
    65        
     65
    6666        movl r10 = (RR_MASK)
    6767        and r9 = r10, r9
    6868        movl r10 = (((RID_KERNEL7) << RID_SHIFT) | (KERNEL_PAGE_WIDTH << PS_SHIFT))
    6969        or r9 = r10, r9
    70        
     70
    7171        mov rr[r8] = r9
    72        
     72
    7373        movl r8 = (VRN_KERNEL << VRN_SHIFT)
    7474        mov cr.ifa = r8
    75        
     75
    7676        mov r11 = cr.itir
    7777        movl r10 = (KERNEL_PAGE_WIDTH << PS_SHIFT)
    7878        or r10 = r10, r11
    7979        mov cr.itir = r10
    80        
     80
    8181        movl r10 = (KERNEL_TRANSLATION_I)
    8282        itr.i itr[r0] = r10
    8383        movl r10 = (KERNEL_TRANSLATION_D)
    8484        itr.d dtr[r0] = r10
    85        
     85
    8686        # Initialize DCR
    87        
     87
    8888        movl r10 = (DCR_DP_MASK | DCR_DK_MASK | DCR_DX_MASK | DCR_DR_MASK | DCR_DA_MASK | DCR_DD_MASK | DCR_LC_MASK)
    8989        mov r9 = cr.dcr
    9090        or r10 = r10, r9
    9191        mov cr.dcr = r10
    92        
     92
    9393        # Initialize PSR
    94        
     94
    9595        movl r10 = (PSR_DT_MASK | PSR_RT_MASK | PSR_IT_MASK | PSR_IC_MASK)  /* Enable paging */
    9696        mov r9 = psr
    97        
     97
    9898        or r10 = r10, r9
    9999        mov cr.ipsr = r10
    … …  
    103103        srlz.d
    104104        srlz.i
    105        
     105
    106106        .explicit
    107        
     107
    108108        /*
    109109         * Return From Interrupt is the only way to
    … …  
    113113
    114114paging_start:
    115        
     115
    116116        /*
    117117         * Now we are paging.
    … …  
    126126        srlz.d ;;
    127127
    128        
     128
    129129        # Switch to register bank 1
    130130        bsw.1
    131        
     131
    132132        # Initialize register stack
    133133        mov ar.rsc = r0
    … …  
    135135        mov ar.bspstore = r8
    136136        loadrs
    137        
     137
    138138        #
    139139        # Initialize memory stack to some sane value and allocate a scratch area
    … …  
    142142        movl sp = stack0 ;;
    143143        add sp = -16, sp
    144        
     144
    145145        # Initialize gp (Global Pointer) register
    146146        movl gp = __gp
    147        
     147
    148148        #
    149149        # Initialize bootinfo on BSP.
    … …  
    153153        addl r21 = @gprel(bootinfo), gp ;;
    154154        st8 [r21] = r20
    155        
     155
    156156        ssm (1 << 19) ;; /* Disable f32 - f127 */
    157157        srlz.i
    158158        srlz.d ;;
    159        
     159
    160160        br.call.sptk.many b0 = ia64_pre_main
    1611610:
Note: See TracChangeset for help on using the changeset viewer.