kernel/arch/sparc/lib/atomic_64.S

   1 /* atomic.S: These things are too big to do inline.
   2  *
   3  * Copyright (C) 1999, 2007 2012 David S. Miller (davem@davemloft.net)
   4  */
   5
   6 #include <linux/linkage.h>
   7 #include <asm/asi.h>
   8 #include <asm/backoff.h>
   9
  10         .text
  11
  12         /* Two versions of the atomic routines, one that
  13          * does not return a value and does not perform
  14          * memory barriers, and a second which returns
  15          * a value and does the barriers.
  16          */
  17
  18 #define ATOMIC_OP(op)                                                   \
  19 ENTRY(atomic_##op) /* %o0 = increment, %o1 = atomic_ptr */              \
  20         BACKOFF_SETUP(%o2);                                             \
  21 1:      lduw    [%o1], %g1;                                             \
  22         op      %g1, %o0, %g7;                                          \
  23         cas     [%o1], %g1, %g7;                                        \
  24         cmp     %g1, %g7;                                               \
  25         bne,pn  %icc, BACKOFF_LABEL(2f, 1b);                            \
  26          nop;                                                           \
  27         retl;                                                           \
  28          nop;                                                           \
  29 2:      BACKOFF_SPIN(%o2, %o3, 1b);                                     \
  30 ENDPROC(atomic_##op);                                                   \
  31
  32 #define ATOMIC_OP_RETURN(op)                                            \
  33 ENTRY(atomic_##op##_return) /* %o0 = increment, %o1 = atomic_ptr */     \
  34         BACKOFF_SETUP(%o2);                                             \
  35 1:      lduw    [%o1], %g1;                                             \
  36         op      %g1, %o0, %g7;                                          \
  37         cas     [%o1], %g1, %g7;                                        \
  38         cmp     %g1, %g7;                                               \
  39         bne,pn  %icc, BACKOFF_LABEL(2f, 1b);                            \
  40          op     %g1, %o0, %g1;                                          \
  41         retl;                                                           \
  42          sra    %g1, 0, %o0;                                            \
  43 2:      BACKOFF_SPIN(%o2, %o3, 1b);                                     \
  44 ENDPROC(atomic_##op##_return);
  45
  46 #define ATOMIC_OPS(op) ATOMIC_OP(op) ATOMIC_OP_RETURN(op)
  47
  48 ATOMIC_OPS(add)
  49 ATOMIC_OPS(sub)
  50
  51 #undef ATOMIC_OPS
  52 #undef ATOMIC_OP_RETURN
  53 #undef ATOMIC_OP
  54
  55 #define ATOMIC64_OP(op)                                                 \
  56 ENTRY(atomic64_##op) /* %o0 = increment, %o1 = atomic_ptr */            \
  57         BACKOFF_SETUP(%o2);                                             \
  58 1:      ldx     [%o1], %g1;                                             \
  59         op      %g1, %o0, %g7;                                          \
  60         casx    [%o1], %g1, %g7;                                        \
  61         cmp     %g1, %g7;                                               \
  62         bne,pn  %xcc, BACKOFF_LABEL(2f, 1b);                            \
  63          nop;                                                           \
  64         retl;                                                           \
  65          nop;                                                           \
  66 2:      BACKOFF_SPIN(%o2, %o3, 1b);                                     \
  67 ENDPROC(atomic64_##op);                                                 \
  68
  69 #define ATOMIC64_OP_RETURN(op)                                          \
  70 ENTRY(atomic64_##op##_return) /* %o0 = increment, %o1 = atomic_ptr */   \
  71         BACKOFF_SETUP(%o2);                                             \
  72 1:      ldx     [%o1], %g1;                                             \
  73         op      %g1, %o0, %g7;                                          \
  74         casx    [%o1], %g1, %g7;                                        \
  75         cmp     %g1, %g7;                                               \
  76         bne,pn  %xcc, BACKOFF_LABEL(2f, 1b);                            \
  77          nop;                                                           \
  78         retl;                                                           \
  79          op     %g1, %o0, %o0;                                          \
  80 2:      BACKOFF_SPIN(%o2, %o3, 1b);                                     \
  81 ENDPROC(atomic64_##op##_return);
  82
  83 #define ATOMIC64_OPS(op) ATOMIC64_OP(op) ATOMIC64_OP_RETURN(op)
  84
  85 ATOMIC64_OPS(add)
  86 ATOMIC64_OPS(sub)
  87
  88 #undef ATOMIC64_OPS
  89 #undef ATOMIC64_OP_RETURN
  90 #undef ATOMIC64_OP
  91
  92 ENTRY(atomic64_dec_if_positive) /* %o0 = atomic_ptr */
  93         BACKOFF_SETUP(%o2)
  94 1:      ldx     [%o0], %g1
  95         brlez,pn %g1, 3f
  96          sub    %g1, 1, %g7
  97         casx    [%o0], %g1, %g7
  98         cmp     %g1, %g7
  99         bne,pn  %xcc, BACKOFF_LABEL(2f, 1b)
 100          nop
 101 3:      retl
 102          sub    %g1, 1, %o0
 103 2:      BACKOFF_SPIN(%o2, %o3, 1b)
 104 ENDPROC(atomic64_dec_if_positive)