Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r7a0359b r7d60cf5  
    2727 */
    2828
    29 /** @addtogroup sparc64
     29/** @addtogroup sparc64 
    3030 * @{
    3131 */
    … …  
    3737
    3838#include <arch/arch.h>
     39#include <arch/types.h>
    3940#include <typedefs.h>
    4041#include <align.h>
    … …  
    4344#include <arch/stack.h>
    4445#include <arch/barrier.h>
    45 #include <trace.h>
    46 
    47 NO_TRACE static inline void pio_write_8(ioport8_t *port, uint8_t v)
     46
     47static inline void pio_write_8(ioport8_t *port, uint8_t v)
    4848{
    4949        *port = v;
    … …  
    5151}
    5252
    53 NO_TRACE static inline void pio_write_16(ioport16_t *port, uint16_t v)
     53static inline void pio_write_16(ioport16_t *port, uint16_t v)
    5454{
    5555        *port = v;
    … …  
    5757}
    5858
    59 NO_TRACE static inline void pio_write_32(ioport32_t *port, uint32_t v)
     59static inline void pio_write_32(ioport32_t *port, uint32_t v)
    6060{
    6161        *port = v;
    … …  
    6363}
    6464
    65 NO_TRACE static inline uint8_t pio_read_8(ioport8_t *port)
    66 {
    67         uint8_t rv = *port;
    68         memory_barrier();
     65static inline uint8_t pio_read_8(ioport8_t *port)
     66{
     67        uint8_t rv;
     68
     69        rv = *port;
     70        memory_barrier();
     71
    6972        return rv;
    7073}
    7174
    72 NO_TRACE static inline uint16_t pio_read_16(ioport16_t *port)
    73 {
    74         uint16_t rv = *port;
    75         memory_barrier();
     75static inline uint16_t pio_read_16(ioport16_t *port)
     76{
     77        uint16_t rv;
     78
     79        rv = *port;
     80        memory_barrier();
     81
    7682        return rv;
    7783}
    7884
    79 NO_TRACE static inline uint32_t pio_read_32(ioport32_t *port)
    80 {
    81         uint32_t rv = *port;
    82         memory_barrier();
     85static inline uint32_t pio_read_32(ioport32_t *port)
     86{
     87        uint32_t rv;
     88
     89        rv = *port;
     90        memory_barrier();
     91
    8392        return rv;
    8493}
    … …  
    8796 *
    8897 * @return Value of PSTATE register.
    89  *
    90  */
    91 NO_TRACE static inline uint64_t pstate_read(void)
    92 {
    93         uint64_t v;
    94        
    95         asm volatile (
    96                 "rdpr %%pstate, %[v]\n"
    97                 : [v] "=r" (v)
    98         );
     98 */
     99static inline uint64_t pstate_read(void)
     100{
     101        uint64_t v;
     102       
     103        asm volatile ("rdpr %%pstate, %0\n" : "=r" (v));
    99104       
    100105        return v;
    … …  
    104109 *
    105110 * @param v New value of PSTATE register.
    106  *
    107  */
    108 NO_TRACE static inline void pstate_write(uint64_t v)
    109 {
    110         asm volatile (
    111                 "wrpr %[v], %[zero], %%pstate\n"
    112                 :: [v] "r" (v),
    113                    [zero] "i" (0)
    114         );
     111 */
     112static inline void pstate_write(uint64_t v)
     113{
     114        asm volatile ("wrpr %0, %1, %%pstate\n" : : "r" (v), "i" (0));
    115115}
    116116
    … …  
    118118 *
    119119 * @return Value of TICK_comapre register.
    120  *
    121  */
    122 NO_TRACE static inline uint64_t tick_compare_read(void)
    123 {
    124         uint64_t v;
    125        
    126         asm volatile (
    127                 "rd %%tick_cmpr, %[v]\n"
    128                 : [v] "=r" (v)
    129         );
     120 */
     121static inline uint64_t tick_compare_read(void)
     122{
     123        uint64_t v;
     124       
     125        asm volatile ("rd %%tick_cmpr, %0\n" : "=r" (v));
    130126       
    131127        return v;
    … …  
    135131 *
    136132 * @param v New value of TICK_comapre register.
    137  *
    138  */
    139 NO_TRACE static inline void tick_compare_write(uint64_t v)
    140 {
    141         asm volatile (
    142                 "wr %[v], %[zero], %%tick_cmpr\n"
    143                 :: [v] "r" (v),
    144                    [zero] "i" (0)
    145         );
     133 */
     134static inline void tick_compare_write(uint64_t v)
     135{
     136        asm volatile ("wr %0, %1, %%tick_cmpr\n" : : "r" (v), "i" (0));
    146137}
    147138
    … …  
    149140 *
    150141 * @return Value of STICK_compare register.
    151  *
    152  */
    153 NO_TRACE static inline uint64_t stick_compare_read(void)
    154 {
    155         uint64_t v;
    156        
    157         asm volatile (
    158                 "rd %%asr25, %[v]\n"
    159                 : [v] "=r" (v)
    160         );
     142 */
     143static inline uint64_t stick_compare_read(void)
     144{
     145        uint64_t v;
     146       
     147        asm volatile ("rd %%asr25, %0\n" : "=r" (v));
    161148       
    162149        return v;
    … …  
    166153 *
    167154 * @param v New value of STICK_comapre register.
    168  *
    169  */
    170 NO_TRACE static inline void stick_compare_write(uint64_t v)
    171 {
    172         asm volatile (
    173                 "wr %[v], %[zero], %%asr25\n"
    174                 :: [v] "r" (v),
    175                    [zero] "i" (0)
    176         );
     155 */
     156static inline void stick_compare_write(uint64_t v)
     157{
     158        asm volatile ("wr %0, %1, %%asr25\n" : : "r" (v), "i" (0));
    177159}
    178160
    … …  
    180162 *
    181163 * @return Value of TICK register.
    182  *
    183  */
    184 NO_TRACE static inline uint64_t tick_read(void)
    185 {
    186         uint64_t v;
    187        
    188         asm volatile (
    189                 "rdpr %%tick, %[v]\n"
    190                 : [v] "=r" (v)
    191         );
     164 */
     165static inline uint64_t tick_read(void)
     166{
     167        uint64_t v;
     168       
     169        asm volatile ("rdpr %%tick, %0\n" : "=r" (v));
    192170       
    193171        return v;
    … …  
    197175 *
    198176 * @param v New value of TICK register.
    199  *
    200  */
    201 NO_TRACE static inline void tick_write(uint64_t v)
    202 {
    203         asm volatile (
    204                 "wrpr %[v], %[zero], %%tick\n"
    205                 :: [v] "r" (v),
    206                    [zero] "i" (0)
    207         );
     177 */
     178static inline void tick_write(uint64_t v)
     179{
     180        asm volatile ("wrpr %0, %1, %%tick\n" : : "r" (v), "i" (0));
    208181}
    209182
    … …  
    211184 *
    212185 * @return Value of FPRS register.
    213  *
    214  */
    215 NO_TRACE static inline uint64_t fprs_read(void)
    216 {
    217         uint64_t v;
    218        
    219         asm volatile (
    220                 "rd %%fprs, %[v]\n"
    221                 : [v] "=r" (v)
    222         );
     186 */
     187static inline uint64_t fprs_read(void)
     188{
     189        uint64_t v;
     190       
     191        asm volatile ("rd %%fprs, %0\n" : "=r" (v));
    223192       
    224193        return v;
    … …  
    228197 *
    229198 * @param v New value of FPRS register.
    230  *
    231  */
    232 NO_TRACE static inline void fprs_write(uint64_t v)
    233 {
    234         asm volatile (
    235                 "wr %[v], %[zero], %%fprs\n"
    236                 :: [v] "r" (v),
    237                    [zero] "i" (0)
    238         );
     199 */
     200static inline void fprs_write(uint64_t v)
     201{
     202        asm volatile ("wr %0, %1, %%fprs\n" : : "r" (v), "i" (0));
    239203}
    240204
    … …  
    242206 *
    243207 * @return Value of SOFTINT register.
    244  *
    245  */
    246 NO_TRACE static inline uint64_t softint_read(void)
    247 {
    248         uint64_t v;
    249        
    250         asm volatile (
    251                 "rd %%softint, %[v]\n"
    252                 : [v] "=r" (v)
    253         );
    254        
     208 */
     209static inline uint64_t softint_read(void)
     210{
     211        uint64_t v;
     212
     213        asm volatile ("rd %%softint, %0\n" : "=r" (v));
     214
    255215        return v;
    256216}
    … …  
    259219 *
    260220 * @param v New value of SOFTINT register.
    261  *
    262  */
    263 NO_TRACE static inline void softint_write(uint64_t v)
    264 {
    265         asm volatile (
    266                 "wr %[v], %[zero], %%softint\n"
    267                 :: [v] "r" (v),
    268                    [zero] "i" (0)
    269         );
     221 */
     222static inline void softint_write(uint64_t v)
     223{
     224        asm volatile ("wr %0, %1, %%softint\n" : : "r" (v), "i" (0));
    270225}
    271226
    … …  
    275230 *
    276231 * @param v New value of CLEAR_SOFTINT register.
    277  *
    278  */
    279 NO_TRACE static inline void clear_softint_write(uint64_t v)
    280 {
    281         asm volatile (
    282                 "wr %[v], %[zero], %%clear_softint\n"
    283                 :: [v] "r" (v),
    284                    [zero] "i" (0)
    285         );
     232 */
     233static inline void clear_softint_write(uint64_t v)
     234{
     235        asm volatile ("wr %0, %1, %%clear_softint\n" : : "r" (v), "i" (0));
    286236}
    287237
    … …  
    291241 *
    292242 * @param v New value of SET_SOFTINT register.
    293  *
    294  */
    295 NO_TRACE static inline void set_softint_write(uint64_t v)
    296 {
    297         asm volatile (
    298                 "wr %[v], %[zero], %%set_softint\n"
    299                 :: [v] "r" (v),
    300                    [zero] "i" (0)
    301         );
     243 */
     244static inline void set_softint_write(uint64_t v)
     245{
     246        asm volatile ("wr %0, %1, %%set_softint\n" : : "r" (v), "i" (0));
    302247}
    303248
    … …  
    308253 *
    309254 * @return Old interrupt priority level.
    310  *
    311  */
    312 NO_TRACE static inline ipl_t interrupts_enable(void) {
     255 */
     256static inline ipl_t interrupts_enable(void) {
    313257        pstate_reg_t pstate;
    314         uint64_t value = pstate_read();
    315        
     258        uint64_t value;
     259       
     260        value = pstate_read();
    316261        pstate.value = value;
    317262        pstate.ie = true;
    … …  
    327272 *
    328273 * @return Old interrupt priority level.
    329  *
    330  */
    331 NO_TRACE static inline ipl_t interrupts_disable(void) {
     274 */
     275static inline ipl_t interrupts_disable(void) {
    332276        pstate_reg_t pstate;
    333         uint64_t value = pstate_read();
    334        
     277        uint64_t value;
     278       
     279        value = pstate_read();
    335280        pstate.value = value;
    336281        pstate.ie = false;
    … …  
    345290 *
    346291 * @param ipl Saved interrupt priority level.
    347  *
    348  */
    349 NO_TRACE static inline void interrupts_restore(ipl_t ipl) {
     292 */
     293static inline void interrupts_restore(ipl_t ipl) {
    350294        pstate_reg_t pstate;
    351295       
    … …  
    360304 *
    361305 * @return Current interrupt priority level.
    362  *
    363  */
    364 NO_TRACE static inline ipl_t interrupts_read(void) {
     306 */
     307static inline ipl_t interrupts_read(void) {
    365308        return (ipl_t) pstate_read();
    366 }
    367 
    368 /** Check interrupts state.
    369  *
    370  * @return True if interrupts are disabled.
    371  *
    372  */
    373 NO_TRACE static inline bool interrupts_disabled(void)
    374 {
    375         pstate_reg_t pstate;
    376        
    377         pstate.value = pstate_read();
    378         return !pstate.ie;
    379309}
    380310
    … …  
    384314 * The stack is assumed to be STACK_SIZE bytes long.
    385315 * The stack must start on page boundary.
    386  *
    387  */
    388 NO_TRACE static inline uintptr_t get_stack_base(void)
     316 */
     317static inline uintptr_t get_stack_base(void)
    389318{
    390319        uintptr_t unbiased_sp;
    391320       
    392         asm volatile (
    393                 "add %%sp, %[stack_bias], %[unbiased_sp]\n"
    394                 : [unbiased_sp] "=r" (unbiased_sp)
    395                 : [stack_bias] "i" (STACK_BIAS)
    396         );
     321        asm volatile ("add %%sp, %1, %0\n" : "=r" (unbiased_sp) : "i" (STACK_BIAS));
    397322       
    398323        return ALIGN_DOWN(unbiased_sp, STACK_SIZE);
    … …  
    402327 *
    403328 * @return Value of VER register.
    404  *
    405  */
    406 NO_TRACE static inline uint64_t ver_read(void)
    407 {
    408         uint64_t v;
    409        
    410         asm volatile (
    411                 "rdpr %%ver, %[v]\n"
    412                 : [v] "=r" (v)
    413         );
     329 */
     330static inline uint64_t ver_read(void)
     331{
     332        uint64_t v;
     333       
     334        asm volatile ("rdpr %%ver, %0\n" : "=r" (v));
    414335       
    415336        return v;
    … …  
    419340 *
    420341 * @return Current value in TPC.
    421  *
    422  */
    423 NO_TRACE static inline uint64_t tpc_read(void)
    424 {
    425         uint64_t v;
    426        
    427         asm volatile (
    428                 "rdpr %%tpc, %[v]\n"
    429                 : [v] "=r" (v)
    430         );
     342 */
     343static inline uint64_t tpc_read(void)
     344{
     345        uint64_t v;
     346       
     347        asm volatile ("rdpr %%tpc, %0\n" : "=r" (v));
    431348       
    432349        return v;
    … …  
    436353 *
    437354 * @return Current value in TL.
    438  *
    439  */
    440 NO_TRACE static inline uint64_t tl_read(void)
    441 {
    442         uint64_t v;
    443        
    444         asm volatile (
    445                 "rdpr %%tl, %[v]\n"
    446                 : [v] "=r" (v)
    447         );
     355 */
     356static inline uint64_t tl_read(void)
     357{
     358        uint64_t v;
     359       
     360        asm volatile ("rdpr %%tl, %0\n" : "=r" (v));
    448361       
    449362        return v;
    … …  
    453366 *
    454367 * @return Current value in TBA.
    455  *
    456  */
    457 NO_TRACE static inline uint64_t tba_read(void)
    458 {
    459         uint64_t v;
    460        
    461         asm volatile (
    462                 "rdpr %%tba, %[v]\n"
    463                 : [v] "=r" (v)
    464         );
     368 */
     369static inline uint64_t tba_read(void)
     370{
     371        uint64_t v;
     372       
     373        asm volatile ("rdpr %%tba, %0\n" : "=r" (v));
    465374       
    466375        return v;
    … …  
    470379 *
    471380 * @param v New value of TBA.
    472  *
    473  */
    474 NO_TRACE static inline void tba_write(uint64_t v)
    475 {
    476         asm volatile (
    477                 "wrpr %[v], %[zero], %%tba\n"
    478                 :: [v] "r" (v),
    479                    [zero] "i" (0)
    480         );
     381 */
     382static inline void tba_write(uint64_t v)
     383{
     384        asm volatile ("wrpr %0, %1, %%tba\n" : : "r" (v), "i" (0));
    481385}
    482386
    … …  
    484388 *
    485389 * @param asi ASI determining the alternate space.
    486  * @param va  Virtual address within the ASI.
    487  *
    488  * @return Value read from the virtual address in
    489  *         the specified address space.
    490  *
    491  */
    492 NO_TRACE static inline uint64_t asi_u64_read(asi_t asi, uintptr_t va)
    493 {
    494         uint64_t v;
    495        
    496         asm volatile (
    497                 "ldxa [%[va]] %[asi], %[v]\n"
    498                 : [v] "=r" (v)
    499                 : [va] "r" (va),
    500                   [asi] "i" ((unsigned int) asi)
    501         );
     390 * @param va Virtual address within the ASI.
     391 *
     392 * @return Value read from the virtual address in the specified address space.
     393 */
     394static inline uint64_t asi_u64_read(asi_t asi, uintptr_t va)
     395{
     396        uint64_t v;
     397       
     398        asm volatile ("ldxa [%1] %2, %0\n" : "=r" (v) : "r" (va), "i" ((unsigned) asi));
    502399       
    503400        return v;
    … …  
    507404 *
    508405 * @param asi ASI determining the alternate space.
    509  * @param va  Virtual address within the ASI.
    510  * @param v   Value to be written.
    511  *
    512  */
    513 NO_TRACE static inline void asi_u64_write(asi_t asi, uintptr_t va, uint64_t v)
    514 {
    515         asm volatile (
    516                 "stxa %[v], [%[va]] %[asi]\n"
    517                 :: [v] "r" (v),
    518                    [va] "r" (va),
    519                    [asi] "i" ((unsigned int) asi)
    520                 : "memory"
    521         );
     406 * @param va Virtual address within the ASI.
     407 * @param v Value to be written.
     408 */
     409static inline void asi_u64_write(asi_t asi, uintptr_t va, uint64_t v)
     410{
     411        asm volatile ("stxa %0, [%1] %2\n" : :  "r" (v), "r" (va), "i" ((unsigned) asi) : "memory");
    522412}
    523413
    524414/** Flush all valid register windows to memory. */
    525 NO_TRACE static inline void flushw(void)
     415static inline void flushw(void)
    526416{
    527417        asm volatile ("flushw\n");
    … …  
    529419
    530420/** Switch to nucleus by setting TL to 1. */
    531 NO_TRACE static inline void nucleus_enter(void)
     421static inline void nucleus_enter(void)
    532422{
    533423        asm volatile ("wrpr %g0, 1, %tl\n");
    … …  
    535425
    536426/** Switch from nucleus by setting TL to 0. */
    537 NO_TRACE static inline void nucleus_leave(void)
     427static inline void nucleus_leave(void)
    538428{
    539429        asm volatile ("wrpr %g0, %g0, %tl\n");
    540430}
    541431
    542 extern void cpu_halt(void) __attribute__((noreturn));
     432extern void cpu_halt(void);
    543433extern void cpu_sleep(void);
    544434extern void asm_delay_loop(const uint32_t usec);
    545435
    546 extern uint64_t read_from_ag_g6(void);
    547436extern uint64_t read_from_ag_g7(void);
    548437extern void write_to_ag_g6(uint64_t val);
Note: See TracChangeset for help on using the changeset viewer.