Changeset a35b458 in mainline for kernel/arch/sparc64/include


Ignore:
Timestamp:
2018-03-02T20:10:49Z (8 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/sparc64/include/arch
Files:
10 edited

Legend:

Unmodified
Added
Removed

  • kernel/arch/sparc64/include/arch/asm.h

    r3061bc1 ra35b458  
    9191{
    9292        uint64_t v;
    93        
     93
    9494        asm volatile (
    9595                "rdpr %%pstate, %[v]\n"
    9696                : [v] "=r" (v)
    9797        );
    98        
     98
    9999        return v;
    100100}
    … …  
    122122{
    123123        uint64_t v;
    124        
     124
    125125        asm volatile (
    126126                "rd %%tick_cmpr, %[v]\n"
    127127                : [v] "=r" (v)
    128128        );
    129        
     129
    130130        return v;
    131131}
    … …  
    153153{
    154154        uint64_t v;
    155        
     155
    156156        asm volatile (
    157157                "rd %%asr25, %[v]\n"
    158158                : [v] "=r" (v)
    159159        );
    160        
     160
    161161        return v;
    162162}
    … …  
    184184{
    185185        uint64_t v;
    186        
     186
    187187        asm volatile (
    188188                "rdpr %%tick, %[v]\n"
    189189                : [v] "=r" (v)
    190190        );
    191        
     191
    192192        return v;
    193193}
    … …  
    215215{
    216216        uint64_t v;
    217        
     217
    218218        asm volatile (
    219219                "rd %%fprs, %[v]\n"
    220220                : [v] "=r" (v)
    221221        );
    222        
     222
    223223        return v;
    224224}
    … …  
    246246{
    247247        uint64_t v;
    248        
     248
    249249        asm volatile (
    250250                "rd %%softint, %[v]\n"
    251251                : [v] "=r" (v)
    252252        );
    253        
     253
    254254        return v;
    255255}
    … …  
    312312        pstate_reg_t pstate;
    313313        uint64_t value = pstate_read();
    314        
     314
    315315        pstate.value = value;
    316316        pstate.ie = true;
    317317        pstate_write(pstate.value);
    318        
     318
    319319        return (ipl_t) value;
    320320}
    … …  
    331331        pstate_reg_t pstate;
    332332        uint64_t value = pstate_read();
    333        
     333
    334334        pstate.value = value;
    335335        pstate.ie = false;
    336336        pstate_write(pstate.value);
    337        
     337
    338338        return (ipl_t) value;
    339339}
    … …  
    348348NO_TRACE static inline void interrupts_restore(ipl_t ipl) {
    349349        pstate_reg_t pstate;
    350        
     350
    351351        pstate.value = pstate_read();
    352352        pstate.ie = ((pstate_reg_t)(uint64_t) ipl).ie;
    … …  
    373373{
    374374        pstate_reg_t pstate;
    375        
     375
    376376        pstate.value = pstate_read();
    377377        return !pstate.ie;
    … …  
    388388{
    389389        uintptr_t unbiased_sp;
    390        
     390
    391391        asm volatile (
    392392                "add %%sp, %[stack_bias], %[unbiased_sp]\n"
    … …  
    394394                : [stack_bias] "i" (STACK_BIAS)
    395395        );
    396        
     396
    397397        return ALIGN_DOWN(unbiased_sp, STACK_SIZE);
    398398}
    … …  
    406406{
    407407        uint64_t v;
    408        
     408
    409409        asm volatile (
    410410                "rdpr %%ver, %[v]\n"
    411411                : [v] "=r" (v)
    412412        );
    413        
     413
    414414        return v;
    415415}
    … …  
    423423{
    424424        uint64_t v;
    425        
     425
    426426        asm volatile (
    427427                "rdpr %%tpc, %[v]\n"
    428428                : [v] "=r" (v)
    429429        );
    430        
     430
    431431        return v;
    432432}
    … …  
    440440{
    441441        uint64_t v;
    442        
     442
    443443        asm volatile (
    444444                "rdpr %%tl, %[v]\n"
    445445                : [v] "=r" (v)
    446446        );
    447        
     447
    448448        return v;
    449449}
    … …  
    457457{
    458458        uint64_t v;
    459        
     459
    460460        asm volatile (
    461461                "rdpr %%tba, %[v]\n"
    462462                : [v] "=r" (v)
    463463        );
    464        
     464
    465465        return v;
    466466}
    … …  
    492492{
    493493        uint64_t v;
    494        
     494
    495495        asm volatile (
    496496                "ldxa [%[va]] %[asi], %[v]\n"
    … …  
    499499                  [asi] "i" ((unsigned int) asi)
    500500        );
    501        
     501
    502502        return v;
    503503}

  • kernel/arch/sparc64/include/arch/atomic.h

    r3061bc1 ra35b458  
    5656        atomic_count_t a;
    5757        atomic_count_t b;
    58        
     58
    5959        do {
    6060                volatile uintptr_t ptr = (uintptr_t) &val->count;
    61                
     61
    6262                a = *((atomic_count_t *) ptr);
    6363                b = a + i;
    64                
     64
    6565                asm volatile (
    6666                        "casx %0, %2, %1\n"
    … …  
    7070                );
    7171        } while (a != b);
    72        
     72
    7373        return a;
    7474}
    … …  
    108108        atomic_count_t v = 1;
    109109        volatile uintptr_t ptr = (uintptr_t) &val->count;
    110        
     110
    111111        asm volatile (
    112112                "casx %0, %2, %1\n"
    … …  
    115115            : "r" (0)
    116116        );
    117        
     117
    118118        return v;
    119119}
    … …  
    123123        atomic_count_t tmp1 = 1;
    124124        atomic_count_t tmp2 = 0;
    125        
     125
    126126        volatile uintptr_t ptr = (uintptr_t) &val->count;
    127        
     127
    128128        preemption_disable();
    129        
     129
    130130        asm volatile (
    131131                "0:\n"
    … …  
    144144                : "r" (0)
    145145        );
    146        
     146
    147147        /*
    148148         * Prevent critical section code from bleeding out this way up.

  • kernel/arch/sparc64/include/arch/barrier.h

    r3061bc1 ra35b458  
    8383{
    8484        unsigned long pc;
    85        
     85
    8686        /*
    8787         * The FLUSH instruction takes address parameter.
    … …  
    9494         *
    9595         */
    96        
     96
    9797        asm volatile (
    9898                "rd %%pc, %[pc]\n"

  • kernel/arch/sparc64/include/arch/cpu_family.h

    r3061bc1 ra35b458  
    7676        return (impl == IMPL_ULTRASPARCIV) || (impl == IMPL_ULTRASPARCIV_PLUS);
    7777}
    78        
     78
    7979#endif
    8080

  • kernel/arch/sparc64/include/arch/mm/sun4u/mmu.h

    r3061bc1 ra35b458  
    111111                unsigned dc : 1;        /**< D-Cache enable. */
    112112                unsigned ic : 1;        /**< I-Cache enable. */
    113                
     113
    114114        } __attribute__ ((packed));
    115115} lsu_cr_reg_t;

  • kernel/arch/sparc64/include/arch/mm/sun4u/tlb.h

    r3061bc1 ra35b458  
    7979#define TLB_DBIG_0      2
    8080#define TLB_DBIG_1      3
    81        
     81
    8282/* I-MMU: one small (16-entry) TLB and one big TLB */
    8383#define TLB_ISMALL      0
    … …  
    327327{
    328328        itlb_data_access_addr_t reg;
    329        
     329
    330330        reg.value = 0;
    331331        reg.tlb_entry = entry;
    … …  
    341341{
    342342        itlb_data_access_addr_t reg;
    343        
     343
    344344        reg.value = 0;
    345345        reg.tlb_entry = entry;
    … …  
    358358{
    359359        dtlb_data_access_addr_t reg;
    360        
     360
    361361        reg.value = 0;
    362362        reg.tlb_entry = entry;
    … …  
    372372{
    373373        dtlb_data_access_addr_t reg;
    374        
     374
    375375        reg.value = 0;
    376376        reg.tlb_entry = entry;
    … …  
    423423{
    424424        itlb_data_access_addr_t reg;
    425        
     425
    426426        reg.value = 0;
    427427        reg.tlb_number = tlb;
    … …  
    439439{
    440440        itlb_data_access_addr_t reg;
    441        
     441
    442442        reg.value = 0;
    443443        reg.tlb_number = tlb;
    … …  
    458458{
    459459        dtlb_data_access_addr_t reg;
    460        
     460
    461461        reg.value = 0;
    462462        reg.tlb_number = tlb;
    … …  
    475475{
    476476        dtlb_data_access_addr_t reg;
    477        
     477
    478478        reg.value = 0;
    479479        reg.tlb_number = tlb;
    … …  
    638638        tlb_demap_addr_t da;
    639639        page_address_t pg;
    640        
     640
    641641        da.value = 0;
    642642        pg.address = page;
    643        
     643
    644644        da.type = type;
    645645        da.context = context_encoding;
    646646        da.vpn = pg.vpn;
    647        
     647
    648648        /* da.value is the address within the ASI */
    649649        asi_u64_write(ASI_IMMU_DEMAP, da.value, 0);
    … …  
    664664        tlb_demap_addr_t da;
    665665        page_address_t pg;
    666        
     666
    667667        da.value = 0;
    668668        pg.address = page;
    669        
     669
    670670        da.type = type;
    671671        da.context = context_encoding;
    672672        da.vpn = pg.vpn;
    673        
     673
    674674        /* da.value is the address within the ASI */
    675675        asi_u64_write(ASI_DMMU_DEMAP, da.value, 0);

  • kernel/arch/sparc64/include/arch/mm/sun4v/mmu.h

    r3061bc1 ra35b458  
    4141#define VA_PRIMARY_CONTEXT_REG          0x8     /**< primary context register VA. */
    4242#define ASI_PRIMARY_CONTEXT_REG         0x21    /**< primary context register ASI. */
    43  
     43
    4444#define VA_SECONDARY_CONTEXT_REG        0x10    /**< secondary context register VA. */
    4545#define ASI_SECONDARY_CONTEXT_REG       0x21    /**< secondary context register ASI. */

  • kernel/arch/sparc64/include/arch/sun4u/asm.h

    r3061bc1 ra35b458  
    4646{
    4747        uint64_t v;
    48        
     48
    4949        asm volatile (
    5050                "rdpr %%ver, %[v]\n"
    5151                : [v] "=r" (v)
    5252        );
    53        
     53
    5454        return v;
    5555}

  • kernel/arch/sparc64/include/arch/sun4u/cpu.h

    r3061bc1 ra35b458  
    7878        uint64_t icbus_config = asi_u64_read(ASI_ICBUS_CONFIG, 0);
    7979        icbus_config = icbus_config >> ICBUS_CONFIG_MID_SHIFT;
    80        
     80
    8181#if defined (US)
    8282        return icbus_config & 0x1f;

  • kernel/arch/sparc64/include/arch/sun4v/hypercall.h

    r3061bc1 ra35b458  
    105105        set function_number, %o5; \
    106106        ta FAST_TRAP;
    107        
     107
    108108/**
    109109 * Performs a fast hypervisor API call from the assembly language code.
    … …  
    197197        register uint64_t a4 asm("o3") = p4;
    198198        register uint64_t a5 asm("o4") = p5;
    199        
     199
    200200        asm volatile (
    201201                "ta %8\n"
    … …  
    239239                : "memory"
    240240        );
    241        
     241
    242242        return a1;
    243243}
Note: See TracChangeset for help on using the changeset viewer.