Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r2ee907e r7a0359b  
    2727 */
    2828
    29 /** @addtogroup sparc64 
     29/** @addtogroup sparc64
    3030 * @{
    3131 */
    … …  
    4343#include <arch/stack.h>
    4444#include <arch/barrier.h>
    45 
    46 static inline void pio_write_8(ioport8_t *port, uint8_t v)
     45#include <trace.h>
     46
     47NO_TRACE static inline void pio_write_8(ioport8_t *port, uint8_t v)
    4748{
    4849        *port = v;
    … …  
    5051}
    5152
    52 static inline void pio_write_16(ioport16_t *port, uint16_t v)
     53NO_TRACE static inline void pio_write_16(ioport16_t *port, uint16_t v)
    5354{
    5455        *port = v;
    … …  
    5657}
    5758
    58 static inline void pio_write_32(ioport32_t *port, uint32_t v)
     59NO_TRACE static inline void pio_write_32(ioport32_t *port, uint32_t v)
    5960{
    6061        *port = v;
    … …  
    6263}
    6364
    64 static inline uint8_t pio_read_8(ioport8_t *port)
    65 {
    66         uint8_t rv;
    67 
    68         rv = *port;
     65NO_TRACE static inline uint8_t pio_read_8(ioport8_t *port)
     66{
     67        uint8_t rv = *port;
    6968        memory_barrier();
    70 
    7169        return rv;
    7270}
    7371
    74 static inline uint16_t pio_read_16(ioport16_t *port)
    75 {
    76         uint16_t rv;
    77 
    78         rv = *port;
     72NO_TRACE static inline uint16_t pio_read_16(ioport16_t *port)
     73{
     74        uint16_t rv = *port;
    7975        memory_barrier();
    80 
    8176        return rv;
    8277}
    8378
    84 static inline uint32_t pio_read_32(ioport32_t *port)
    85 {
    86         uint32_t rv;
    87 
    88         rv = *port;
     79NO_TRACE static inline uint32_t pio_read_32(ioport32_t *port)
     80{
     81        uint32_t rv = *port;
    8982        memory_barrier();
    90 
    9183        return rv;
    9284}
    … …  
    9587 *
    9688 * @return Value of PSTATE register.
    97  */
    98 static inline uint64_t pstate_read(void)
    99 {
    100         uint64_t v;
    101        
    102         asm volatile ("rdpr %%pstate, %0\n" : "=r" (v));
     89 *
     90 */
     91NO_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        );
    10399       
    104100        return v;
    … …  
    108104 *
    109105 * @param v New value of PSTATE register.
    110  */
    111 static inline void pstate_write(uint64_t v)
    112 {
    113         asm volatile ("wrpr %0, %1, %%pstate\n" : : "r" (v), "i" (0));
     106 *
     107 */
     108NO_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        );
    114115}
    115116
    … …  
    117118 *
    118119 * @return Value of TICK_comapre register.
    119  */
    120 static inline uint64_t tick_compare_read(void)
    121 {
    122         uint64_t v;
    123        
    124         asm volatile ("rd %%tick_cmpr, %0\n" : "=r" (v));
     120 *
     121 */
     122NO_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        );
    125130       
    126131        return v;
    … …  
    130135 *
    131136 * @param v New value of TICK_comapre register.
    132  */
    133 static inline void tick_compare_write(uint64_t v)
    134 {
    135         asm volatile ("wr %0, %1, %%tick_cmpr\n" : : "r" (v), "i" (0));
     137 *
     138 */
     139NO_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        );
    136146}
    137147
    … …  
    139149 *
    140150 * @return Value of STICK_compare register.
    141  */
    142 static inline uint64_t stick_compare_read(void)
    143 {
    144         uint64_t v;
    145        
    146         asm volatile ("rd %%asr25, %0\n" : "=r" (v));
     151 *
     152 */
     153NO_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        );
    147161       
    148162        return v;
    … …  
    152166 *
    153167 * @param v New value of STICK_comapre register.
    154  */
    155 static inline void stick_compare_write(uint64_t v)
    156 {
    157         asm volatile ("wr %0, %1, %%asr25\n" : : "r" (v), "i" (0));
     168 *
     169 */
     170NO_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        );
    158177}
    159178
    … …  
    161180 *
    162181 * @return Value of TICK register.
    163  */
    164 static inline uint64_t tick_read(void)
    165 {
    166         uint64_t v;
    167        
    168         asm volatile ("rdpr %%tick, %0\n" : "=r" (v));
     182 *
     183 */
     184NO_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        );
    169192       
    170193        return v;
    … …  
    174197 *
    175198 * @param v New value of TICK register.
    176  */
    177 static inline void tick_write(uint64_t v)
    178 {
    179         asm volatile ("wrpr %0, %1, %%tick\n" : : "r" (v), "i" (0));
     199 *
     200 */
     201NO_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        );
    180208}
    181209
    … …  
    183211 *
    184212 * @return Value of FPRS register.
    185  */
    186 static inline uint64_t fprs_read(void)
    187 {
    188         uint64_t v;
    189        
    190         asm volatile ("rd %%fprs, %0\n" : "=r" (v));
     213 *
     214 */
     215NO_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        );
    191223       
    192224        return v;
    … …  
    196228 *
    197229 * @param v New value of FPRS register.
    198  */
    199 static inline void fprs_write(uint64_t v)
    200 {
    201         asm volatile ("wr %0, %1, %%fprs\n" : : "r" (v), "i" (0));
     230 *
     231 */
     232NO_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        );
    202239}
    203240
    … …  
    205242 *
    206243 * @return Value of SOFTINT register.
    207  */
    208 static inline uint64_t softint_read(void)
    209 {
    210         uint64_t v;
    211 
    212         asm volatile ("rd %%softint, %0\n" : "=r" (v));
    213 
     244 *
     245 */
     246NO_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       
    214255        return v;
    215256}
    … …  
    218259 *
    219260 * @param v New value of SOFTINT register.
    220  */
    221 static inline void softint_write(uint64_t v)
    222 {
    223         asm volatile ("wr %0, %1, %%softint\n" : : "r" (v), "i" (0));
     261 *
     262 */
     263NO_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        );
    224270}
    225271
    … …  
    229275 *
    230276 * @param v New value of CLEAR_SOFTINT register.
    231  */
    232 static inline void clear_softint_write(uint64_t v)
    233 {
    234         asm volatile ("wr %0, %1, %%clear_softint\n" : : "r" (v), "i" (0));
     277 *
     278 */
     279NO_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        );
    235286}
    236287
    … …  
    240291 *
    241292 * @param v New value of SET_SOFTINT register.
    242  */
    243 static inline void set_softint_write(uint64_t v)
    244 {
    245         asm volatile ("wr %0, %1, %%set_softint\n" : : "r" (v), "i" (0));
     293 *
     294 */
     295NO_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        );
    246302}
    247303
    … …  
    252308 *
    253309 * @return Old interrupt priority level.
    254  */
    255 static inline ipl_t interrupts_enable(void) {
     310 *
     311 */
     312NO_TRACE static inline ipl_t interrupts_enable(void) {
    256313        pstate_reg_t pstate;
    257         uint64_t value;
    258        
    259         value = pstate_read();
     314        uint64_t value = pstate_read();
     315       
    260316        pstate.value = value;
    261317        pstate.ie = true;
    … …  
    271327 *
    272328 * @return Old interrupt priority level.
    273  */
    274 static inline ipl_t interrupts_disable(void) {
     329 *
     330 */
     331NO_TRACE static inline ipl_t interrupts_disable(void) {
    275332        pstate_reg_t pstate;
    276         uint64_t value;
    277        
    278         value = pstate_read();
     333        uint64_t value = pstate_read();
     334       
    279335        pstate.value = value;
    280336        pstate.ie = false;
    … …  
    289345 *
    290346 * @param ipl Saved interrupt priority level.
    291  */
    292 static inline void interrupts_restore(ipl_t ipl) {
     347 *
     348 */
     349NO_TRACE static inline void interrupts_restore(ipl_t ipl) {
    293350        pstate_reg_t pstate;
    294351       
    … …  
    303360 *
    304361 * @return Current interrupt priority level.
    305  */
    306 static inline ipl_t interrupts_read(void) {
     362 *
     363 */
     364NO_TRACE static inline ipl_t interrupts_read(void) {
    307365        return (ipl_t) pstate_read();
     366}
     367
     368/** Check interrupts state.
     369 *
     370 * @return True if interrupts are disabled.
     371 *
     372 */
     373NO_TRACE static inline bool interrupts_disabled(void)
     374{
     375        pstate_reg_t pstate;
     376       
     377        pstate.value = pstate_read();
     378        return !pstate.ie;
    308379}
    309380
    … …  
    313384 * The stack is assumed to be STACK_SIZE bytes long.
    314385 * The stack must start on page boundary.
    315  */
    316 static inline uintptr_t get_stack_base(void)
     386 *
     387 */
     388NO_TRACE static inline uintptr_t get_stack_base(void)
    317389{
    318390        uintptr_t unbiased_sp;
    319391       
    320         asm volatile ("add %%sp, %1, %0\n" : "=r" (unbiased_sp) : "i" (STACK_BIAS));
     392        asm volatile (
     393                "add %%sp, %[stack_bias], %[unbiased_sp]\n"
     394                : [unbiased_sp] "=r" (unbiased_sp)
     395                : [stack_bias] "i" (STACK_BIAS)
     396        );
    321397       
    322398        return ALIGN_DOWN(unbiased_sp, STACK_SIZE);
    … …  
    326402 *
    327403 * @return Value of VER register.
    328  */
    329 static inline uint64_t ver_read(void)
    330 {
    331         uint64_t v;
    332        
    333         asm volatile ("rdpr %%ver, %0\n" : "=r" (v));
     404 *
     405 */
     406NO_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        );
    334414       
    335415        return v;
    … …  
    339419 *
    340420 * @return Current value in TPC.
    341  */
    342 static inline uint64_t tpc_read(void)
    343 {
    344         uint64_t v;
    345        
    346         asm volatile ("rdpr %%tpc, %0\n" : "=r" (v));
     421 *
     422 */
     423NO_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        );
    347431       
    348432        return v;
    … …  
    352436 *
    353437 * @return Current value in TL.
    354  */
    355 static inline uint64_t tl_read(void)
    356 {
    357         uint64_t v;
    358        
    359         asm volatile ("rdpr %%tl, %0\n" : "=r" (v));
     438 *
     439 */
     440NO_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        );
    360448       
    361449        return v;
    … …  
    365453 *
    366454 * @return Current value in TBA.
    367  */
    368 static inline uint64_t tba_read(void)
    369 {
    370         uint64_t v;
    371        
    372         asm volatile ("rdpr %%tba, %0\n" : "=r" (v));
     455 *
     456 */
     457NO_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        );
    373465       
    374466        return v;
    … …  
    378470 *
    379471 * @param v New value of TBA.
    380  */
    381 static inline void tba_write(uint64_t v)
    382 {
    383         asm volatile ("wrpr %0, %1, %%tba\n" : : "r" (v), "i" (0));
     472 *
     473 */
     474NO_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        );
    384481}
    385482
    … …  
    387484 *
    388485 * @param asi ASI determining the alternate space.
    389  * @param va Virtual address within the ASI.
    390  *
    391  * @return Value read from the virtual address in the specified address space.
    392  */
    393 static 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));
     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 */
     492NO_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        );
    398502       
    399503        return v;
    … …  
    403507 *
    404508 * @param asi ASI determining the alternate space.
    405  * @param va Virtual address within the ASI.
    406  * @param v Value to be written.
    407  */
    408 static 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");
     509 * @param va  Virtual address within the ASI.
     510 * @param v   Value to be written.
     511 *
     512 */
     513NO_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        );
    411522}
    412523
    413524/** Flush all valid register windows to memory. */
    414 static inline void flushw(void)
     525NO_TRACE static inline void flushw(void)
    415526{
    416527        asm volatile ("flushw\n");
    … …  
    418529
    419530/** Switch to nucleus by setting TL to 1. */
    420 static inline void nucleus_enter(void)
     531NO_TRACE static inline void nucleus_enter(void)
    421532{
    422533        asm volatile ("wrpr %g0, 1, %tl\n");
    … …  
    424535
    425536/** Switch from nucleus by setting TL to 0. */
    426 static inline void nucleus_leave(void)
     537NO_TRACE static inline void nucleus_leave(void)
    427538{
    428539        asm volatile ("wrpr %g0, %g0, %tl\n");
Note: See TracChangeset for help on using the changeset viewer.