Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r7a0359b r2ee907e  
    2727 */
    2828
    29 /** @addtogroup sparc64
     29/** @addtogroup sparc64 
    3030 * @{
    3131 */
    … …  
    4343#include <arch/stack.h>
    4444#include <arch/barrier.h>
    45 #include <trace.h>
    46 
    47 NO_TRACE static inline void pio_write_8(ioport8_t *port, uint8_t v)
     45
     46static inline void pio_write_8(ioport8_t *port, uint8_t v)
    4847{
    4948        *port = v;
    … …  
    5150}
    5251
    53 NO_TRACE static inline void pio_write_16(ioport16_t *port, uint16_t v)
     52static inline void pio_write_16(ioport16_t *port, uint16_t v)
    5453{
    5554        *port = v;
    … …  
    5756}
    5857
    59 NO_TRACE static inline void pio_write_32(ioport32_t *port, uint32_t v)
     58static inline void pio_write_32(ioport32_t *port, uint32_t v)
    6059{
    6160        *port = v;
    … …  
    6362}
    6463
    65 NO_TRACE static inline uint8_t pio_read_8(ioport8_t *port)
    66 {
    67         uint8_t rv = *port;
    68         memory_barrier();
     64static inline uint8_t pio_read_8(ioport8_t *port)
     65{
     66        uint8_t rv;
     67
     68        rv = *port;
     69        memory_barrier();
     70
    6971        return rv;
    7072}
    7173
    72 NO_TRACE static inline uint16_t pio_read_16(ioport16_t *port)
    73 {
    74         uint16_t rv = *port;
    75         memory_barrier();
     74static inline uint16_t pio_read_16(ioport16_t *port)
     75{
     76        uint16_t rv;
     77
     78        rv = *port;
     79        memory_barrier();
     80
    7681        return rv;
    7782}
    7883
    79 NO_TRACE static inline uint32_t pio_read_32(ioport32_t *port)
    80 {
    81         uint32_t rv = *port;
    82         memory_barrier();
     84static inline uint32_t pio_read_32(ioport32_t *port)
     85{
     86        uint32_t rv;
     87
     88        rv = *port;
     89        memory_barrier();
     90
    8391        return rv;
    8492}
    … …  
    8795 *
    8896 * @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         );
     97 */
     98static inline uint64_t pstate_read(void)
     99{
     100        uint64_t v;
     101       
     102        asm volatile ("rdpr %%pstate, %0\n" : "=r" (v));
    99103       
    100104        return v;
    … …  
    104108 *
    105109 * @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         );
     110 */
     111static inline void pstate_write(uint64_t v)
     112{
     113        asm volatile ("wrpr %0, %1, %%pstate\n" : : "r" (v), "i" (0));
    115114}
    116115
    … …  
    118117 *
    119118 * @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         );
     119 */
     120static inline uint64_t tick_compare_read(void)
     121{
     122        uint64_t v;
     123       
     124        asm volatile ("rd %%tick_cmpr, %0\n" : "=r" (v));
    130125       
    131126        return v;
    … …  
    135130 *
    136131 * @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         );
     132 */
     133static inline void tick_compare_write(uint64_t v)
     134{
     135        asm volatile ("wr %0, %1, %%tick_cmpr\n" : : "r" (v), "i" (0));
    146136}
    147137
    … …  
    149139 *
    150140 * @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         );
     141 */
     142static inline uint64_t stick_compare_read(void)
     143{
     144        uint64_t v;
     145       
     146        asm volatile ("rd %%asr25, %0\n" : "=r" (v));
    161147       
    162148        return v;
    … …  
    166152 *
    167153 * @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         );
     154 */
     155static inline void stick_compare_write(uint64_t v)
     156{
     157        asm volatile ("wr %0, %1, %%asr25\n" : : "r" (v), "i" (0));
    177158}
    178159
    … …  
    180161 *
    181162 * @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         );
     163 */
     164static inline uint64_t tick_read(void)
     165{
     166        uint64_t v;
     167       
     168        asm volatile ("rdpr %%tick, %0\n" : "=r" (v));
    192169       
    193170        return v;
    … …  
    197174 *
    198175 * @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         );
     176 */
     177static inline void tick_write(uint64_t v)
     178{
     179        asm volatile ("wrpr %0, %1, %%tick\n" : : "r" (v), "i" (0));
    208180}
    209181
    … …  
    211183 *
    212184 * @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         );
     185 */
     186static inline uint64_t fprs_read(void)
     187{
     188        uint64_t v;
     189       
     190        asm volatile ("rd %%fprs, %0\n" : "=r" (v));
    223191       
    224192        return v;
    … …  
    228196 *
    229197 * @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         );
     198 */
     199static inline void fprs_write(uint64_t v)
     200{
     201        asm volatile ("wr %0, %1, %%fprs\n" : : "r" (v), "i" (0));
    239202}
    240203
    … …  
    242205 *
    243206 * @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        
     207 */
     208static inline uint64_t softint_read(void)
     209{
     210        uint64_t v;
     211
     212        asm volatile ("rd %%softint, %0\n" : "=r" (v));
     213
    255214        return v;
    256215}
    … …  
    259218 *
    260219 * @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         );
     220 */
     221static inline void softint_write(uint64_t v)
     222{
     223        asm volatile ("wr %0, %1, %%softint\n" : : "r" (v), "i" (0));
    270224}
    271225
    … …  
    275229 *
    276230 * @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         );
     231 */
     232static inline void clear_softint_write(uint64_t v)
     233{
     234        asm volatile ("wr %0, %1, %%clear_softint\n" : : "r" (v), "i" (0));
    286235}
    287236
    … …  
    291240 *
    292241 * @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         );
     242 */
     243static inline void set_softint_write(uint64_t v)
     244{
     245        asm volatile ("wr %0, %1, %%set_softint\n" : : "r" (v), "i" (0));
    302246}
    303247
    … …  
    308252 *
    309253 * @return Old interrupt priority level.
    310  *
    311  */
    312 NO_TRACE static inline ipl_t interrupts_enable(void) {
     254 */
     255static inline ipl_t interrupts_enable(void) {
    313256        pstate_reg_t pstate;
    314         uint64_t value = pstate_read();
    315        
     257        uint64_t value;
     258       
     259        value = pstate_read();
    316260        pstate.value = value;
    317261        pstate.ie = true;
    … …  
    327271 *
    328272 * @return Old interrupt priority level.
    329  *
    330  */
    331 NO_TRACE static inline ipl_t interrupts_disable(void) {
     273 */
     274static inline ipl_t interrupts_disable(void) {
    332275        pstate_reg_t pstate;
    333         uint64_t value = pstate_read();
    334        
     276        uint64_t value;
     277       
     278        value = pstate_read();
    335279        pstate.value = value;
    336280        pstate.ie = false;
    … …  
    345289 *
    346290 * @param ipl Saved interrupt priority level.
    347  *
    348  */
    349 NO_TRACE static inline void interrupts_restore(ipl_t ipl) {
     291 */
     292static inline void interrupts_restore(ipl_t ipl) {
    350293        pstate_reg_t pstate;
    351294       
    … …  
    360303 *
    361304 * @return Current interrupt priority level.
    362  *
    363  */
    364 NO_TRACE static inline ipl_t interrupts_read(void) {
     305 */
     306static inline ipl_t interrupts_read(void) {
    365307        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;
    379308}
    380309
    … …  
    384313 * The stack is assumed to be STACK_SIZE bytes long.
    385314 * The stack must start on page boundary.
    386  *
    387  */
    388 NO_TRACE static inline uintptr_t get_stack_base(void)
     315 */
     316static inline uintptr_t get_stack_base(void)
    389317{
    390318        uintptr_t unbiased_sp;
    391319       
    392         asm volatile (
    393                 "add %%sp, %[stack_bias], %[unbiased_sp]\n"
    394                 : [unbiased_sp] "=r" (unbiased_sp)
    395                 : [stack_bias] "i" (STACK_BIAS)
    396         );
     320        asm volatile ("add %%sp, %1, %0\n" : "=r" (unbiased_sp) : "i" (STACK_BIAS));
    397321       
    398322        return ALIGN_DOWN(unbiased_sp, STACK_SIZE);
    … …  
    402326 *
    403327 * @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         );
     328 */
     329static inline uint64_t ver_read(void)
     330{
     331        uint64_t v;
     332       
     333        asm volatile ("rdpr %%ver, %0\n" : "=r" (v));
    414334       
    415335        return v;
    … …  
    419339 *
    420340 * @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         );
     341 */
     342static inline uint64_t tpc_read(void)
     343{
     344        uint64_t v;
     345       
     346        asm volatile ("rdpr %%tpc, %0\n" : "=r" (v));
    431347       
    432348        return v;
    … …  
    436352 *
    437353 * @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         );
     354 */
     355static inline uint64_t tl_read(void)
     356{
     357        uint64_t v;
     358       
     359        asm volatile ("rdpr %%tl, %0\n" : "=r" (v));
    448360       
    449361        return v;
    … …  
    453365 *
    454366 * @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         );
     367 */
     368static inline uint64_t tba_read(void)
     369{
     370        uint64_t v;
     371       
     372        asm volatile ("rdpr %%tba, %0\n" : "=r" (v));
    465373       
    466374        return v;
    … …  
    470378 *
    471379 * @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         );
     380 */
     381static inline void tba_write(uint64_t v)
     382{
     383        asm volatile ("wrpr %0, %1, %%tba\n" : : "r" (v), "i" (0));
    481384}
    482385
    … …  
    484387 *
    485388 * @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         );
     389 * @param va Virtual address within the ASI.
     390 *
     391 * @return Value read from the virtual address in the specified address space.
     392 */
     393static inline uint64_t asi_u64_read(asi_t asi, uintptr_t va)
     394{
     395        uint64_t v;
     396       
     397        asm volatile ("ldxa [%1] %2, %0\n" : "=r" (v) : "r" (va), "i" ((unsigned) asi));
    502398       
    503399        return v;
    … …  
    507403 *
    508404 * @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         );
     405 * @param va Virtual address within the ASI.
     406 * @param v Value to be written.
     407 */
     408static inline void asi_u64_write(asi_t asi, uintptr_t va, uint64_t v)
     409{
     410        asm volatile ("stxa %0, [%1] %2\n" : :  "r" (v), "r" (va), "i" ((unsigned) asi) : "memory");
    522411}
    523412
    524413/** Flush all valid register windows to memory. */
    525 NO_TRACE static inline void flushw(void)
     414static inline void flushw(void)
    526415{
    527416        asm volatile ("flushw\n");
    … …  
    529418
    530419/** Switch to nucleus by setting TL to 1. */
    531 NO_TRACE static inline void nucleus_enter(void)
     420static inline void nucleus_enter(void)
    532421{
    533422        asm volatile ("wrpr %g0, 1, %tl\n");
    … …  
    535424
    536425/** Switch from nucleus by setting TL to 0. */
    537 NO_TRACE static inline void nucleus_leave(void)
     426static inline void nucleus_leave(void)
    538427{
    539428        asm volatile ("wrpr %g0, %g0, %tl\n");
Note: See TracChangeset for help on using the changeset viewer.