Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r7d60cf5 r7a0359b  
    2727 */
    2828
    29 /** @addtogroup sparc64 
     29/** @addtogroup sparc64
    3030 * @{
    3131 */
    … …  
    3737
    3838#include <arch/arch.h>
    39 #include <arch/types.h>
    4039#include <typedefs.h>
    4140#include <align.h>
    … …  
    4443#include <arch/stack.h>
    4544#include <arch/barrier.h>
    46 
    47 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)
    4848{
    4949        *port = v;
    … …  
    5151}
    5252
    53 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)
    5454{
    5555        *port = v;
    … …  
    5757}
    5858
    59 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)
    6060{
    6161        *port = v;
    … …  
    6363}
    6464
    65 static inline uint8_t pio_read_8(ioport8_t *port)
    66 {
    67         uint8_t rv;
    68 
    69         rv = *port;
     65NO_TRACE static inline uint8_t pio_read_8(ioport8_t *port)
     66{
     67        uint8_t rv = *port;
    7068        memory_barrier();
    71 
    7269        return rv;
    7370}
    7471
    75 static inline uint16_t pio_read_16(ioport16_t *port)
    76 {
    77         uint16_t rv;
    78 
    79         rv = *port;
     72NO_TRACE static inline uint16_t pio_read_16(ioport16_t *port)
     73{
     74        uint16_t rv = *port;
    8075        memory_barrier();
    81 
    8276        return rv;
    8377}
    8478
    85 static inline uint32_t pio_read_32(ioport32_t *port)
    86 {
    87         uint32_t rv;
    88 
    89         rv = *port;
     79NO_TRACE static inline uint32_t pio_read_32(ioport32_t *port)
     80{
     81        uint32_t rv = *port;
    9082        memory_barrier();
    91 
    9283        return rv;
    9384}
    … …  
    9687 *
    9788 * @return Value of PSTATE register.
    98  */
    99 static inline uint64_t pstate_read(void)
    100 {
    101         uint64_t v;
    102        
    103         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        );
    10499       
    105100        return v;
    … …  
    109104 *
    110105 * @param v New value of PSTATE register.
    111  */
    112 static inline void pstate_write(uint64_t v)
    113 {
    114         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        );
    115115}
    116116
    … …  
    118118 *
    119119 * @return Value of TICK_comapre register.
    120  */
    121 static inline uint64_t tick_compare_read(void)
    122 {
    123         uint64_t v;
    124        
    125         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        );
    126130       
    127131        return v;
    … …  
    131135 *
    132136 * @param v New value of TICK_comapre register.
    133  */
    134 static inline void tick_compare_write(uint64_t v)
    135 {
    136         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        );
    137146}
    138147
    … …  
    140149 *
    141150 * @return Value of STICK_compare register.
    142  */
    143 static inline uint64_t stick_compare_read(void)
    144 {
    145         uint64_t v;
    146        
    147         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        );
    148161       
    149162        return v;
    … …  
    153166 *
    154167 * @param v New value of STICK_comapre register.
    155  */
    156 static inline void stick_compare_write(uint64_t v)
    157 {
    158         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        );
    159177}
    160178
    … …  
    162180 *
    163181 * @return Value of TICK register.
    164  */
    165 static inline uint64_t tick_read(void)
    166 {
    167         uint64_t v;
    168        
    169         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        );
    170192       
    171193        return v;
    … …  
    175197 *
    176198 * @param v New value of TICK register.
    177  */
    178 static inline void tick_write(uint64_t v)
    179 {
    180         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        );
    181208}
    182209
    … …  
    184211 *
    185212 * @return Value of FPRS register.
    186  */
    187 static inline uint64_t fprs_read(void)
    188 {
    189         uint64_t v;
    190        
    191         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        );
    192223       
    193224        return v;
    … …  
    197228 *
    198229 * @param v New value of FPRS register.
    199  */
    200 static inline void fprs_write(uint64_t v)
    201 {
    202         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        );
    203239}
    204240
    … …  
    206242 *
    207243 * @return Value of SOFTINT register.
    208  */
    209 static inline uint64_t softint_read(void)
    210 {
    211         uint64_t v;
    212 
    213         asm volatile ("rd %%softint, %0\n" : "=r" (v));
    214 
     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       
    215255        return v;
    216256}
    … …  
    219259 *
    220260 * @param v New value of SOFTINT register.
    221  */
    222 static inline void softint_write(uint64_t v)
    223 {
    224         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        );
    225270}
    226271
    … …  
    230275 *
    231276 * @param v New value of CLEAR_SOFTINT register.
    232  */
    233 static inline void clear_softint_write(uint64_t v)
    234 {
    235         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        );
    236286}
    237287
    … …  
    241291 *
    242292 * @param v New value of SET_SOFTINT register.
    243  */
    244 static inline void set_softint_write(uint64_t v)
    245 {
    246         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        );
    247302}
    248303
    … …  
    253308 *
    254309 * @return Old interrupt priority level.
    255  */
    256 static inline ipl_t interrupts_enable(void) {
     310 *
     311 */
     312NO_TRACE static inline ipl_t interrupts_enable(void) {
    257313        pstate_reg_t pstate;
    258         uint64_t value;
    259        
    260         value = pstate_read();
     314        uint64_t value = pstate_read();
     315       
    261316        pstate.value = value;
    262317        pstate.ie = true;
    … …  
    272327 *
    273328 * @return Old interrupt priority level.
    274  */
    275 static inline ipl_t interrupts_disable(void) {
     329 *
     330 */
     331NO_TRACE static inline ipl_t interrupts_disable(void) {
    276332        pstate_reg_t pstate;
    277         uint64_t value;
    278        
    279         value = pstate_read();
     333        uint64_t value = pstate_read();
     334       
    280335        pstate.value = value;
    281336        pstate.ie = false;
    … …  
    290345 *
    291346 * @param ipl Saved interrupt priority level.
    292  */
    293 static inline void interrupts_restore(ipl_t ipl) {
     347 *
     348 */
     349NO_TRACE static inline void interrupts_restore(ipl_t ipl) {
    294350        pstate_reg_t pstate;
    295351       
    … …  
    304360 *
    305361 * @return Current interrupt priority level.
    306  */
    307 static inline ipl_t interrupts_read(void) {
     362 *
     363 */
     364NO_TRACE static inline ipl_t interrupts_read(void) {
    308365        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;
    309379}
    310380
    … …  
    314384 * The stack is assumed to be STACK_SIZE bytes long.
    315385 * The stack must start on page boundary.
    316  */
    317 static inline uintptr_t get_stack_base(void)
     386 *
     387 */
     388NO_TRACE static inline uintptr_t get_stack_base(void)
    318389{
    319390        uintptr_t unbiased_sp;
    320391       
    321         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        );
    322397       
    323398        return ALIGN_DOWN(unbiased_sp, STACK_SIZE);
    … …  
    327402 *
    328403 * @return Value of VER register.
    329  */
    330 static inline uint64_t ver_read(void)
    331 {
    332         uint64_t v;
    333        
    334         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        );
    335414       
    336415        return v;
    … …  
    340419 *
    341420 * @return Current value in TPC.
    342  */
    343 static inline uint64_t tpc_read(void)
    344 {
    345         uint64_t v;
    346        
    347         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        );
    348431       
    349432        return v;
    … …  
    353436 *
    354437 * @return Current value in TL.
    355  */
    356 static inline uint64_t tl_read(void)
    357 {
    358         uint64_t v;
    359        
    360         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        );
    361448       
    362449        return v;
    … …  
    366453 *
    367454 * @return Current value in TBA.
    368  */
    369 static inline uint64_t tba_read(void)
    370 {
    371         uint64_t v;
    372        
    373         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        );
    374465       
    375466        return v;
    … …  
    379470 *
    380471 * @param v New value of TBA.
    381  */
    382 static inline void tba_write(uint64_t v)
    383 {
    384         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        );
    385481}
    386482
    … …  
    388484 *
    389485 * @param asi ASI determining the alternate space.
    390  * @param va Virtual address within the ASI.
    391  *
    392  * @return Value read from the virtual address in the specified address space.
    393  */
    394 static 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));
     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        );
    399502       
    400503        return v;
    … …  
    404507 *
    405508 * @param asi ASI determining the alternate space.
    406  * @param va Virtual address within the ASI.
    407  * @param v Value to be written.
    408  */
    409 static 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");
     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        );
    412522}
    413523
    414524/** Flush all valid register windows to memory. */
    415 static inline void flushw(void)
     525NO_TRACE static inline void flushw(void)
    416526{
    417527        asm volatile ("flushw\n");
    … …  
    419529
    420530/** Switch to nucleus by setting TL to 1. */
    421 static inline void nucleus_enter(void)
     531NO_TRACE static inline void nucleus_enter(void)
    422532{
    423533        asm volatile ("wrpr %g0, 1, %tl\n");
    … …  
    425535
    426536/** Switch from nucleus by setting TL to 0. */
    427 static inline void nucleus_leave(void)
     537NO_TRACE static inline void nucleus_leave(void)
    428538{
    429539        asm volatile ("wrpr %g0, %g0, %tl\n");
    430540}
    431541
    432 extern void cpu_halt(void);
     542extern void cpu_halt(void) __attribute__((noreturn));
    433543extern void cpu_sleep(void);
    434544extern void asm_delay_loop(const uint32_t usec);
    435545
     546extern uint64_t read_from_ag_g6(void);
    436547extern uint64_t read_from_ag_g7(void);
    437548extern void write_to_ag_g6(uint64_t val);
Note: See TracChangeset for help on using the changeset viewer.